LIAB_BASE = 938.09
style_factors = {"Sedan": 1.0, "SUV": 1.05, ...}

for row in reader:
    age = int(float(row["driver_age"]))
    style = row["vehicle_style"]
    miles = float(row["annual_mileage"])

    # age factor
    if age <= 25:
        af = 1.6
    elif age < 30:
        af = 1.15
    ...
    sf = style_factors[style]
    liab = round(LIAB_BASE * sf * af * mf, 2)
    ...
    row["change"] = round(new_prem / old_prem - 1, 4)

$ python price_book.py quote_requests.csv q.csv
Traceback (most recent call last):
  ...
KeyError: 'liab_premium'

ratingkit/
├── pyproject.toml      # name, dependencies, tools
├── uv.lock             # exact versions, committed
├── README.md
├── src/
│   └── ratingkit/
│       ├── __init__.py   # the public API
│       ├── schemas.py    # validated inputs
│       ├── manual.py     # the rating manual
│       ├── manuals/motor_2025.toml
│       ├── algorithms.py # one rater per coverage
│       ├── factory.py    # raters chosen by name
│       ├── engine.py     # RatingEngine, Quote
│       ├── book.py       # files in, files out
│       └── cli.py        # the ratingkit command
└── tests/

[project]
name = "ratingkit"
version = "1.0.0"
requires-python = ">=3.12"
dependencies = ["pandas>=2.2", "pydantic>=2.9"]

[project.scripts]
ratingkit = "ratingkit.cli:main"     # a command

[build-system]
requires = ["uv_build>=0.11,<0.12"]
build-backend = "uv_build"

[dependency-groups]
dev = ["pytest>=8", "hypothesis>=6.100",
       "ruff>=0.8", "mypy>=1.13"]

$ uv sync                  # .venv + locked versions
$ uv run ratingkit book_2025.csv priced.csv
18,249 vehicles priced, 0 rejected
$ uv run ratingkit quote_requests.csv q.csv \
      --id-column quote_id
963 vehicles priced, 37 rejected

# src/ratingkit/__init__.py
"""ratingkit: the motor rating manual as a tested,
typed Python package."""

from ratingkit.engine import Quote, RatingEngine
from ratingkit.manual import RatingManual, load_manual
from ratingkit.schemas import Vehicle

__all__ = ["Quote", "RatingEngine", "RatingManual",
           "Vehicle", "load_manual"]

# a user of the package
from ratingkit import Vehicle, load_manual
from ratingkit.factory import build_engine

engine = build_engine(load_manual())

from typing import Literal, Protocol

Coverage = Literal["LIAB", "COLL", "COMP"]
Style = Literal["Sedan", "SUV", "Hatchback",
                "Pickup", "Minivan", "Sports"]

def earned(total: float, exposure: float) -> float: ...

coll_deductible: int | None = None     # optional

class CoverageRater(Protocol):         # any object with
    def premium(self, vehicle: Vehicle) -> float: ...

from pydantic import BaseModel, ConfigDict, Field, model_validator

class Vehicle(BaseModel):
    model_config = ConfigDict(frozen=True, extra="ignore")

    driver_age: float = Field(ge=16, le=110)
    vehicle_style: Style
    vehicle_value: float = Field(gt=0, le=500_000)
    annual_mileage: float = Field(gt=0, le=150_000)
    urban: bool
    coverages: Annotated[frozenset[Coverage],
                         BeforeValidator(_split)]  # "LIAB|COLL"
    coll_deductible: Deductible | None = None
    comp_deductible: Deductible | None = None

    @model_validator(mode="after")
    def _coverages_consistent(self) -> Self:
        if "LIAB" not in self.coverages:
            raise ValueError("liability (LIAB) is compulsory")
        ...  # a deductible if and only if the cover is bought
        return self

Vehicle.model_validate({"driver_age": "3", ...})
# ValidationError: driver_age
#   Input should be greater than or equal to 16

# motor_2025.toml
[base_rate]          # annual premium, base risk
LIAB = 938.09
COLL = 576.85
COMP = 158.35

[style]              # LIAB and COLL
Sedan = 1.00
Sports = 1.40        # ...

[driver_age]         # bands are [lower, upper)
upper  = [25, 30, 65, 75, 200]
factor = [1.60, 1.15, 1.00, 1.10, 1.35]

[deductible]         # COLL and COMP
250 = 1.10
500 = 1.00
1000 = 0.88

class BandTable(BaseModel):
    upper: tuple[float, ...]
    factor: tuple[float, ...]

    @model_validator(mode="after")
    def _check(self) -> Self:   # bounds must increase
        ...

    def lookup(self, value: float) -> float:
        for upper, factor in zip(self.upper, self.factor,
                                 strict=True):
            if value < upper:
                return factor
        raise ValueError(f"{value} is above the last band")

class CoverageRater(Protocol):
    @property
    def coverage(self) -> Coverage: ...
    def premium(self, vehicle: Vehicle) -> float: ...

@dataclass(frozen=True)
class ManualLiability:
    manual: RatingManual
    coverage: Coverage = "LIAB"

    def premium(self, v: Vehicle) -> float:
        m = self.manual
        return money(m.base_rate["LIAB"] * m.style[v.vehicle_style]
                     * m.driver_age.lookup(v.driver_age)
                     * m.annual_mileage.lookup(v.annual_mileage))

@dataclass(frozen=True)
class UrbanAmendedLiability:     # the Course 3 rate review
    manual: RatingManual
    urban_factor: float = 1.25
    non_urban_factor: float = 0.857
    ...

ALGORITHMS = {
    ("LIAB", "manual"): ManualLiability,
    ("LIAB", "urban_amendment"): UrbanAmendedLiability,
    ("COLL", "manual"): ManualCollision,
    ("COMP", "manual"): ManualComprehensive,
}

def build_engine(manual, choices=None) -> RatingEngine:
    names = {**DEFAULT, **(choices or {})}
    raters = {}
    for coverage, name in names.items():
        try:
            make = ALGORITHMS[(coverage, name)]
        except KeyError:
            raise ValueError(f"no {coverage} algorithm "
                             f"called {name!r}") from None
        raters[coverage] = make(manual)
    return RatingEngine(raters)

$ uv run ratingkit book_2025.csv amended.csv \
      --liability urban_amendment

>>> round(836.645, 2)
836.64          # 836.645 is stored as 836.64499999...

from decimal import ROUND_HALF_UP, Decimal

def money(amount: float) -> float:
    """Round half up, to the cent."""
    return float(Decimal(repr(amount))
                 .quantize(Decimal("0.01"),
                           rounding=ROUND_HALF_UP))

>>> money(836.645)
836.65

• My code is a package in a src/ layout with a pyproject.toml
• Each module has one job; the rating logic never touches files
• Every input is validated, and rejections say which field and why
• I know what lax mode accepts

• The rating manual is a file, validated when loaded
• Each coverage has a rater with the same shape (Strategy)
• Algorithms are chosen by name from configuration (Factory)
• I refactor against a golden master and explain every difference