insurance.mid-term-adjustment Unreviewed

def mid_term_adjustment(old_premium: Money, new_premium: Money, inception_date: str, expiry_date: str, change_date: str, admin_fee: Money, mode: RoundingMode) -> MidTermAdjustment

AdjustmentKind = Literal["additional", "return", "none"]

@dataclass(frozen=True)
class MidTermAdjustment:
    """The premium change for the rest of the term, the fee and what is due."""

    total_days: int
    #: days from changeDate to expiryDate
    remaining_days: int
    #: the difference in premium for the remaining days; negative is a return premium
    premium_change: Money
    admin_fee: Money
    #: premiumChange plus adminFee; negative is owed to the policyholder
    amount_due: Money
    #: additional or return premium by the sign of premiumChange
    kind: AdjustmentKind

from fune.insurance.mid_term_adjustment import mid_term_adjustment  # insurance.mid-term-adjustment@^1

from .dates_days_between import days_between  ← from dates.days-between ^1.0.0 · built alongside by fune
from .insurance_mid_term_adjustment_types import MidTermAdjustment
from .math_round_div import RoundingMode, round_div  ← from math.round-div ^1.0.0 · built alongside by fune
from .money_amount import Money, assert_same_currency, money  ← from money.amount ^1.0.0 · built alongside by fune


def mid_term_adjustment(
    old_premium: Money,
    new_premium: Money,
    inception_date: str,
    expiry_date: str,
    change_date: str,
    admin_fee: Money,
    mode: RoundingMode,
) -> MidTermAdjustment:
    """The additional or return premium for a change part-way through a policy term.

    The difference between the two full-term premiums is pro-rated over the
    days left, with one rounding. Pro-rating the old and new premiums
    separately and subtracting rounds twice and can be a penny out.
    """
    assert_same_currency(old_premium, new_premium)
    assert_same_currency(old_premium, admin_fee)
    if old_premium.minor < 0 or new_premium.minor < 0:
        raise ValueError("premiums must not be negative")
    if admin_fee.minor < 0:
        raise ValueError("adminFee must not be negative, received %d" % (admin_fee.minor,))
    total_days = days_between(inception_date, expiry_date)
    if total_days <= 0:
        raise ValueError(
            "expiryDate must be after inceptionDate, received %s to %s" % (inception_date, expiry_date)
        )
    remaining_days = days_between(change_date, expiry_date)
    if remaining_days < 0 or remaining_days > total_days:
        raise ValueError("changeDate must be from inceptionDate to expiryDate, received %s" % (change_date,))
    change = round_div((new_premium.minor - old_premium.minor) * remaining_days, total_days, mode)
    currency = old_premium.currency
    return MidTermAdjustment(
        total_days=total_days,
        remaining_days=remaining_days,
        premium_change=money(change, currency),
        admin_fee=admin_fee,
        amount_due=money(change + admin_fee.minor, currency),
        kind="additional" if change > 0 else "return" if change < 0 else "none",
    )

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and its 3 dependencies, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add insurance.mid-term-adjustment

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./insurance.mid-term-adjustment-1.0.1-python.fune, or fetch it from a terminal with fune pull insurance.mid-term-adjustment@1.0.1:python.

The whole function, every language, is one file too: insurance.mid-term-adjustment-1.0.1.fune, 23,546 bytes, sha256 20a8cb56d87453621b8f8019e80a7a541baf3ddc581fffb67386f6c0b352b594. It installs into a project of any language.

# fune: before insurance.mid-term-adjustment

# fune: after insurance.mid-term-adjustment

# fune: replace dates.days-between in insurance.mid-term-adjustment
# fune: replace math.round-div in insurance.mid-term-adjustment
# fune: replace money.amount in insurance.mid-term-adjustment

# fune: step insurance.mid-term-adjustment after <n|label>

More from the author

Give it the full-term premium before the change and the full-term premium the policy would cost with the change (as your rating engine quotes it), the term dates and the date the change takes effect. The difference is pro-rated on the days left:

premiumChange = (newPremium - oldPremium) x remainingDays / totalDays

with one rounding, in the caller's mode. Pro-rating the old and the new premium separately and subtracting rounds twice and can be a penny out (the vectors have one such case: 60.16, not 60.17).

`expiryDate` is exclusive (a year from 2026-01-01 ends 2027-01-01), and the days left are `expiryDate - changeDate`, so a change on the inception date is the whole difference and a change on the expiry date is nothing. Leap years count their 366 days.

## The admin fee

`adminFee` is added to what is due whichever way the premium moves, which is how most UK insurers and brokers apply an MTA fee: on a return premium the fee is deducted from the refund, and if the fee is larger the policyholder still pays the difference (`amountDue` positive while `kind` is `return`). Pass zero when no fee is charged. The fee is kept separate from the premium change because it is usually not premium: IPT (`insurance.ipt`) applies to `premiumChange`, and to the fee only when the insurer charges it as part of the premium.

## Not covered here

Short-period loadings on MTAs, minimum additional premiums and "no refund below X" rules are insurer-specific terms of business; apply them to the result.

## Before you rely on this

**Not professional advice.** This capability calculates insurance figures from published rules. It is a software component for developers, not financial advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have an actuary review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified actuary has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

1.0.1 marks it unreviewed. The code and the tests are unchanged.

Files