class QuoteRequest(BaseModel):
    model_config = ConfigDict(frozen=True, extra="forbid",
        json_schema_extra={"examples": [{
            "driver_age": 22, "vehicle_style": "Sports", ...}]})

    driver_age: float = Field(ge=16, le=110,
        description="Age of the youngest listed driver")
    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], ...]
    coll_deductible: Deductible | None = None
    comp_deductible: Deductible | None = None

class QuoteResponse(BaseModel):
    quote_id: int
    premiums: dict[Coverage, float]
    total_premium: float
    liability_basis: Literal["manual", "model"]
    model_version: str
    created_at: datetime

app = FastAPI(title="Motor Rating API", version="1.0.0",
              lifespan=lifespan)

@app.post("/quotes", response_model=QuoteResponse,
          status_code=201,
          dependencies=[Depends(require_api_key)])
def create_quote(body: QuoteRequest, request: Request,
                 s: Db) -> QuoteResponse:
    premiums = request.app.state.rating.quote(body)
    rec = QuoteRecord(request=body.model_dump(mode="json"),
                      liab_premium=premiums["LIAB"], ...,
                      model_version=manifest["version"])
    s.add(rec)
    s.commit()
    return to_response(rec)

@asynccontextmanager
async def lifespan(app):          # once, at start-up
    model, manifest = load(settings.model_dir)   # verified
    app.state.rating = build_engine(load_manual(), model,
                                    settings.liability_basis, ...)
    ...
    yield

$ curl -s -X POST localhost:8000/quotes \
    -H "X-API-Key: $KEY" -H "Content-Type: application/json" \
    -d '{"driver_age": 22, "vehicle_style": "Sports",
         "vehicle_value": 45000, "annual_mileage": 16000,
         "urban": true, "coverages": ["LIAB","COLL","COMP"],
         "coll_deductible": 1000, "comp_deductible": 250}'
{"quote_id": 1,
 "premiums": {"LIAB": 4648.59, "COLL": 2046.76,
              "COMP": 313.53},
 "total_premium": 7008.88,
 "liability_basis": "model",
 "model_version": "glm-dcbe5b5dbb",
 "created_at": "2026-09-30T15:12:17.850368Z"}

{"detail": [
  {"type": "greater_than_equal",
   "loc": ["body", "driver_age"],
   "msg": "Input should be greater than or equal to 16",
   "input": 15, "ctx": {"ge": 16.0}},
  {"type": "literal_error",
   "loc": ["body", "vehicle_style"],
   "msg": "Input should be 'Sedan', 'SUV', 'Hatchback',
           'Pickup', 'Minivan' or 'Sports'",
   "input": "Coupe"}
]}

def require_api_key(
    x_api_key: Annotated[str | None, Header()] = None,
) -> None:
    expected = settings.api_key.get_secret_value()
    if (not expected or x_api_key is None
            or not secrets.compare_digest(x_api_key, expected)):
        raise HTTPException(401, "missing or invalid X-API-Key")

@demo.get("/async-await")
async def good():
    await asyncio.sleep(0.2)   # waits; others run meanwhile
    return {"ok": True}

@demo.get("/async-blocking")
async def bad():
    time.sleep(0.2)            # blocks the loop: all wait
    return {"ok": True}

@demo.get("/sync-def")
def threaded():
    time.sleep(0.2)            # plain def: FastAPI runs it
    return {"ok": True}        # in a worker thread

@pytest.fixture
def client(settings):
    with TestClient(create_app(settings)) as c:   # runs lifespan
        yield c

def test_quote_is_priced_and_stored(client, auth, settings):
    r = client.post("/quotes", json=BODY, headers=auth)
    assert r.status_code == 201
    q = r.json()
    assert q["premiums"]["COLL"] == 2046.76
    assert client.get(f"/quotes/{q['quote_id']}",
                      headers=auth).json() == q

def test_api_key_is_required(client):
    assert client.post("/quotes", json=BODY).status_code == 401

def test_batch_with_one_bad_vehicle_stores_nothing(...):
    ...

• My API has explicit request and response models
• Invalid requests get 422 with the field and reason
• Writes need a key, compared in constant time
• Every quote records the model version that priced it

• The model loads once, at start-up
• I use async def only when everything inside awaits
• Batch endpoints make one model call
• Tests exercise the whole app through TestClient