@pikaa-ai/pikaa 0.3.1 → 0.3.4

package/skills/pkpd-modeling/scripts/simulate_regimen.py

@@ -1,323 +0,0 @@
-#!/usr/bin/env python3
-"""Simulate dosing regimens, with or without between-subject variability.
-
-Deterministic simulation answers "what does the typical patient look like".
-That is almost never the question. The question is what fraction of patients
-stay inside the therapeutic window, and the two answers differ by a lot: a
-regimen whose typical trough sits exactly at the target leaves roughly half the
-population below it.
-
-    python3 simulate_regimen.py --cl 5 --v 40 --dose 500 --interval 12 --n-doses 10
-    python3 simulate_regimen.py --cl 5 --v 40 --q 8 --v2 60 --dose 500 --interval 8 \\
-        --route oral --ka 1.2 --f 0.7 --steady-state
-    python3 simulate_regimen.py --cl 5 --v 40 --dose 500 --interval 12 --simulate 2000 \\
-        --omega-cl 0.35 --omega-v 0.25 --target-trough 2.0
-    python3 simulate_regimen.py --vmax 200 --km 5 --v 40 --dose 300 --interval 24 \\
-        --n-doses 7 --nonlinear
-    python3 simulate_regimen.py --compare "500@12,750@8,1000@24" --cl 5 --v 40
-"""
-
-from __future__ import annotations
-
-import argparse
-import math
-from typing import Sequence
-
-import numpy as np
-
-from _common import InputError, Report, add_format_argument, main_wrapper
-
-from _models import (
-    build_regimen,
-    disposition,
-    simulate_linear,
-    simulate_michaelis_menten,
-    steady_state_metrics,
-)
-
-
-def summarise_interval(evaluate, start: float, end: float, points: int = 4001) -> dict[str, float]:
-    """Summarise one dosing interval on its own dedicated grid.
-
-    The interval is closed at the start (immediately *after* that dose) and
-    open at the end (immediately *before* the next one). Subsetting a shared
-    grid instead gets both ends wrong: a point landing exactly on the next dose
-    reports that dose's peak as this interval's Cmax, and a point landing on
-    this interval's own dose can be read as the previous trough.
-    """
-    window_t = np.linspace(start, end, points)
-    window_t[-1] = end - 1e-9  # pre-dose trough, not the next dose's peak
-    window_c = np.asarray(evaluate(window_t), dtype=float)
-    auc = float(np.trapezoid(window_c, window_t))
-    cmax = float(window_c.max())
-    cmin = float(window_c.min())
-    cavg = auc / (end - start)
-    return {
-        "auc_tau": auc,
-        "cmax": cmax,
-        "tmax": float(window_t[int(np.argmax(window_c))] - start),
-        "cmin": cmin,
-        "cavg": cavg,
-        "peak_trough_fluctuation_pct": 100.0 * (cmax - cmin) / cavg if cavg else float("nan"),
-        "swing": (cmax - cmin) / cmin if cmin > 0 else float("nan"),
-    }
-
-
-def _regimen_spec(text: str) -> tuple[float, float]:
-    if "@" not in text:
-        raise argparse.ArgumentTypeError(f"regimen must look like 500@12 (dose@interval), got {text!r}")
-    dose_text, interval_text = text.split("@", 1)
-    try:
-        return float(dose_text), float(interval_text)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(f"could not parse regimen {text!r}") from exc
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="Simulate single- and multiple-dose regimens, deterministically or with IIV.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    parser.add_argument("--cl", type=float, help="clearance")
-    parser.add_argument("--v", type=float, required=True, help="central volume")
-    parser.add_argument("--q", type=float, action="append", default=[], help="intercompartmental clearance (repeatable)")
-    parser.add_argument("--v2", type=float, action="append", default=[], help="peripheral volume (repeatable, pairs with --q)")
-    parser.add_argument("--route", choices=("iv-bolus", "iv-infusion", "oral"), default="iv-bolus")
-    parser.add_argument("--ka", type=float, help="absorption rate constant for --route oral")
-    parser.add_argument("--f", type=float, default=1.0, help="bioavailable fraction (default: 1.0)")
-    parser.add_argument("--tlag", type=float, default=0.0)
-    parser.add_argument("--tinf", type=float, default=0.0, help="infusion duration for --route iv-infusion")
-
-    parser.add_argument("--dose", type=float, help="dose amount")
-    parser.add_argument("--interval", type=float, help="dosing interval")
-    parser.add_argument("--n-doses", type=int, default=1)
-    parser.add_argument("--loading", type=float, help="different first dose")
-    parser.add_argument("--steady-state", action="store_true", help="report closed-form steady-state metrics")
-    parser.add_argument("--compare", help="comma-separated dose@interval regimens to compare")
-
-    parser.add_argument("--nonlinear", action="store_true", help="Michaelis-Menten elimination instead of linear")
-    parser.add_argument("--vmax", type=float, help="maximum elimination rate (amount/time) for --nonlinear")
-    parser.add_argument("--km", type=float, help="Michaelis constant (concentration) for --nonlinear")
-
-    parser.add_argument("--simulate", type=int, help="number of virtual subjects for a Monte Carlo simulation")
-    parser.add_argument("--omega-cl", type=float, default=0.0, help="between-subject CV of clearance")
-    parser.add_argument("--omega-v", type=float, default=0.0, help="between-subject CV of volume")
-    parser.add_argument("--seed", type=int, default=20260727)
-    parser.add_argument("--target-trough", type=float, help="report the fraction of subjects above this trough")
-    parser.add_argument("--target-peak-below", type=float, help="report the fraction of subjects with a peak below this")
-    parser.add_argument("--target-auc", type=float, help="report the fraction of subjects above this AUC over the interval")
-
-    parser.add_argument("--profile", action="store_true", help="also emit the concentration-time profile")
-    parser.add_argument("--profile-points", type=int, default=25)
-    add_format_argument(parser)
-    return parser
-
-
-def run(argv: Sequence[str] | None = None) -> int:
-    args = build_parser().parse_args(argv)
-    if len(args.q) != len(args.v2):
-        raise InputError(f"{len(args.q)} --q values but {len(args.v2)} --v2 values; they pair up")
-    if args.route == "oral" and args.ka is None:
-        raise InputError("--route oral needs --ka")
-    if args.route == "iv-infusion" and args.tinf <= 0:
-        raise InputError("--route iv-infusion needs a positive --tinf")
-    if args.nonlinear and (args.vmax is None or args.km is None):
-        raise InputError("--nonlinear needs --vmax and --km")
-    if not args.nonlinear and args.cl is None:
-        raise InputError("--cl is required for a linear model")
-
-    report = Report()
-
-    # ---- regimen comparison
-    if args.compare:
-        regimens = [_regimen_spec(chunk.strip()) for chunk in args.compare.split(",")]
-        if args.nonlinear:
-            raise InputError("--compare currently supports linear models only")
-        disp = disposition(args.cl, args.v, args.q, args.v2)
-        rows = []
-        for dose, interval in regimens:
-            metrics = steady_state_metrics(disp, dose, interval, f=args.f)
-            rows.append(
-                {
-                    "regimen": f"{dose:g} q{interval:g}h",
-                    "daily_dose": dose * 24.0 / interval,
-                    "auc_tau_ss": metrics["auc_tau_ss"],
-                    "cavg_ss": metrics["cavg_ss"],
-                    "cmax_ss_bolus": metrics["cmax_ss_bolus"],
-                    "cmin_ss_bolus": metrics["cmin_ss_bolus"],
-                    "ptf_pct": metrics["peak_trough_fluctuation_pct"],
-                    "accumulation_ratio_auc": metrics["accumulation_ratio_auc"],
-                }
-            )
-        report.table("steady-state comparison", rows)
-        report.note(
-            "Cmax and Cmin here are the bolus-equivalent extremes. Average concentration depends only "
-            "on the daily dose and clearance, so regimens matched on daily dose differ in fluctuation, "
-            "not in Cavg."
-        )
-        return report.emit(args.format)
-
-    if args.dose is None or (args.n_doses > 1 and not args.interval):
-        raise InputError("--dose is required, and a multiple-dose regimen needs --interval")
-    interval = args.interval or 0.0
-
-    regimen = build_regimen(
-        args.dose,
-        interval=args.interval,
-        n_doses=args.n_doses,
-        duration=args.tinf,
-        route="oral" if args.route == "oral" else "iv",
-        loading=args.loading,
-    )
-    horizon = interval * args.n_doses if args.n_doses > 1 else max(interval, 1.0) * 10
-    times = np.linspace(0.0, horizon, max(200 * max(args.n_doses, 1), 400) + 1)
-
-    # ---- deterministic profile
-    if args.nonlinear:
-        def evaluate(grid: np.ndarray) -> np.ndarray:
-            return simulate_michaelis_menten(
-                grid,
-                regimen,
-                vmax=args.vmax,
-                km=args.km,
-                v1=args.v,
-                q=args.q,
-                vp=args.v2,
-                ka=args.ka if args.route == "oral" else None,
-                f=args.f,
-            )
-
-        conc = evaluate(times)
-        report.note(
-            "Michaelis-Menten elimination: exposure is not proportional to dose and superposition does "
-            "not apply, so multiple-dose behaviour cannot be inferred from a single-dose profile."
-        )
-        cl_at_steady = args.vmax / (args.km + float(conc.max())) if conc.size else float("nan")
-        report.scalar("clearance_at_peak_concentration", cl_at_steady)
-    else:
-        disp = disposition(args.cl, args.v, args.q, args.v2)
-
-        def evaluate(grid: np.ndarray) -> np.ndarray:
-            return simulate_linear(grid, regimen, disp, ka=args.ka, f=args.f, tlag=args.tlag)
-
-        conc = evaluate(times)
-        report.scalar("terminal_half_life", disp.terminal_half_life)
-        report.scalar("vss", disp.vss)
-        report.scalar("mrt_iv", disp.mrt_iv)
-        for i, half in enumerate(disp.half_lives, start=1):
-            report.scalar(f"t_half_phase{i}", float(half))
-
-    if args.n_doses > 1:
-        last = summarise_interval(evaluate, (args.n_doses - 1) * interval, args.n_doses * interval)
-        first = summarise_interval(evaluate, 0.0, interval)
-        report.table(
-            "dosing-interval summary",
-            [
-                {"interval": "first", **first},
-                {"interval": f"last (#{args.n_doses})", **last},
-                {
-                    "interval": "accumulation (last/first)",
-                    "auc_tau": last["auc_tau"] / first["auc_tau"] if first["auc_tau"] else float("nan"),
-                    "cmax": last["cmax"] / first["cmax"] if first["cmax"] else float("nan"),
-                    "cmin": last["cmin"] / first["cmin"] if first["cmin"] > 0 else float("nan"),
-                    "cavg": last["cavg"] / first["cavg"] if first["cavg"] else float("nan"),
-                },
-            ],
-        )
-    else:
-        report.scalar("cmax", float(conc.max()))
-        report.scalar("tmax", float(times[int(np.argmax(conc))]))
-        report.scalar("auc_over_horizon", float(np.trapezoid(conc, times)))
-
-    if args.steady_state and not args.nonlinear:
-        metrics = steady_state_metrics(disposition(args.cl, args.v, args.q, args.v2), args.dose, interval, f=args.f)
-        report.table("closed-form steady state", [{"metric": k, "value": v} for k, v in metrics.items()])
-        if args.n_doses > 1 and args.n_doses * interval < metrics["time_to_95pct_ss"]:
-            report.finding(
-                f"the simulation covers {args.n_doses * interval:g} time units but 95% of steady state "
-                f"is not reached until {metrics['time_to_95pct_ss']:.1f}; the last interval shown is not "
-                "steady state"
-            )
-
-    # ---- Monte Carlo
-    if args.simulate:
-        if args.nonlinear:
-            raise InputError("--simulate currently supports linear models only")
-        if args.omega_cl <= 0 and args.omega_v <= 0:
-            raise InputError("--simulate needs at least one of --omega-cl or --omega-v above zero")
-        rng = np.random.default_rng(args.seed)
-        n = args.simulate
-        sd_cl = math.sqrt(math.log(1.0 + args.omega_cl**2)) if args.omega_cl > 0 else 0.0
-        sd_v = math.sqrt(math.log(1.0 + args.omega_v**2)) if args.omega_v > 0 else 0.0
-        cl_draws = args.cl * np.exp(rng.normal(0.0, sd_cl, n)) if sd_cl else np.full(n, args.cl)
-        v_draws = args.v * np.exp(rng.normal(0.0, sd_v, n)) if sd_v else np.full(n, args.v)
-
-        start = (args.n_doses - 1) * interval if args.n_doses > 1 else 0.0
-        end = args.n_doses * interval if args.n_doses > 1 else horizon
-        window = np.linspace(start, end, 401)
-        troughs = np.empty(n)
-        peaks = np.empty(n)
-        aucs = np.empty(n)
-        for i in range(n):
-            disp_i = disposition(cl_draws[i], v_draws[i], args.q, args.v2)
-            profile = simulate_linear(window, regimen, disp_i, ka=args.ka, f=args.f, tlag=args.tlag)
-            troughs[i] = profile[-1] if args.n_doses > 1 else profile.min()
-            peaks[i] = profile.max()
-            aucs[i] = float(np.trapezoid(profile, window))
-
-        def percentiles(values: np.ndarray, label: str) -> dict:
-            return {
-                "metric": label,
-                "p5": float(np.percentile(values, 5)),
-                "p25": float(np.percentile(values, 25)),
-                "median": float(np.percentile(values, 50)),
-                "p75": float(np.percentile(values, 75)),
-                "p95": float(np.percentile(values, 95)),
-                "geo_mean": float(np.exp(np.mean(np.log(np.maximum(values, 1e-12))))),
-            }
-
-        report.table(
-            f"simulated population (n = {n})",
-            [percentiles(peaks, "peak"), percentiles(troughs, "trough"), percentiles(aucs, "auc_over_interval")],
-        )
-
-        attainment = []
-        if args.target_trough is not None:
-            fraction = float(np.mean(troughs >= args.target_trough))
-            attainment.append({"target": f"trough >= {args.target_trough:g}", "fraction_attaining": fraction})
-        if args.target_peak_below is not None:
-            fraction = float(np.mean(peaks <= args.target_peak_below))
-            attainment.append({"target": f"peak <= {args.target_peak_below:g}", "fraction_attaining": fraction})
-        if args.target_auc is not None:
-            fraction = float(np.mean(aucs >= args.target_auc))
-            attainment.append({"target": f"AUC >= {args.target_auc:g}", "fraction_attaining": fraction})
-        if args.target_trough is not None and args.target_peak_below is not None:
-            both = float(np.mean((troughs >= args.target_trough) & (peaks <= args.target_peak_below)))
-            attainment.append({"target": "both trough and peak targets", "fraction_attaining": both})
-        if attainment:
-            report.table("probability of target attainment", attainment)
-            for row in attainment:
-                if row["fraction_attaining"] < 0.9:
-                    report.finding(
-                        f"{row['target']}: only {100 * row['fraction_attaining']:.1f}% of simulated "
-                        "subjects attain this target"
-                    )
-        report.note(
-            "Between-subject variability only. Residual/assay variability and between-occasion "
-            "variability would widen these intervals further, so the attainment fractions here are "
-            "optimistic."
-        )
-
-    if args.profile:
-        step = max(len(times) // max(args.profile_points, 1), 1)
-        report.table(
-            "concentration-time profile",
-            [{"time": float(t), "conc": float(c)} for t, c in zip(times[::step], conc[::step])],
-        )
-
-    return report.emit(args.format)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main_wrapper(run))

package/skills/pkpd-modeling/scripts/tdm_bayes.py

@@ -1,312 +0,0 @@
-#!/usr/bin/env python3
-"""Maximum a posteriori Bayesian forecasting for therapeutic drug monitoring.
-
-Given a published population model and one or two measured concentrations,
-MAP estimation produces individual parameters that shrink towards the
-population when the data are uninformative and follow the data when they are
-not. That property is exactly why it beats the alternatives clinicians reach
-for: a single trough interpreted with population parameters ignores the
-individual, and log-linear regression on two points ignores the population and
-falls apart when a level is drawn during distribution.
-
-    python3 tdm_bayes.py --model vancomycin-adult --weight 80 --crcl 75 \\
-        --dose 1500 --interval 12 --level 18.2@11.5 --level 42@1.5
-
-    python3 tdm_bayes.py --custom --cl-pop 4.2 --v-pop 45 --omega-cl 0.30 \\
-        --omega-v 0.25 --prop-error 0.12 --dose 1000 --interval 8 --level 12@7.5
-
-Each ``--level`` is ``concentration@time-after-the-most-recent-dose``. The
-regimen is assumed to have been given long enough to be at steady state unless
-``--doses-given`` says otherwise.
-"""
-
-from __future__ import annotations
-
-import argparse
-import math
-from dataclasses import dataclass
-from typing import Sequence
-
-import numpy as np
-
-from _common import InputError, Report, add_format_argument, main_wrapper
-
-from _models import build_regimen, disposition, simulate_linear
-
-try:
-    from scipy.optimize import minimize
-except ImportError as exc:  # pragma: no cover
-    raise SystemExit("tdm_bayes.py needs scipy: uv pip install scipy") from exc
-
-
-@dataclass
-class PopulationModel:
-    name: str
-    description: str
-    cl_pop: float          # L/h at the reference covariates
-    v_pop: float           # L
-    omega_cl: float        # apparent CV of between-subject variability
-    omega_v: float
-    prop_error: float
-    add_error: float
-    target: str
-    reference: str
-
-    def individualise(self, weight: float | None, crcl: float | None) -> tuple[float, float]:
-        return self.cl_pop, self.v_pop
-
-
-@dataclass
-class VancomycinAdult(PopulationModel):
-    def individualise(self, weight: float | None, crcl: float | None) -> tuple[float, float]:
-        if weight is None or crcl is None:
-            raise InputError("the vancomycin model needs --weight and --crcl")
-        # A conventional two-covariate adult parameterisation: clearance
-        # proportional to creatinine clearance, volume proportional to weight.
-        return 0.048 * crcl, 0.72 * weight
-
-
-LIBRARY: dict[str, PopulationModel] = {
-    "vancomycin-adult": VancomycinAdult(
-        name="vancomycin-adult",
-        description="Adult vancomycin, one compartment, CL from creatinine clearance and V from weight",
-        cl_pop=3.6,
-        v_pop=58.0,
-        omega_cl=0.27,
-        omega_v=0.25,
-        prop_error=0.15,
-        add_error=1.0,
-        target="AUC24/MIC 400-600 with an assumed MIC of 1 mg/L (2020 consensus guideline)",
-        reference="illustrative parameterisation - substitute the model validated for your population",
-    ),
-}
-
-
-def map_estimate(
-    model: PopulationModel,
-    cl_prior: float,
-    v_prior: float,
-    dose: float,
-    interval: float,
-    n_doses: int,
-    infusion: float,
-    levels: list[tuple[float, float]],
-) -> dict:
-    """Minimise the MAP objective: weighted residuals plus the prior penalty.
-
-    The objective is ``sum((obs - pred)^2 / var_i) + sum(eta_k^2 / omega_k^2)``.
-    The second term is what makes this Bayesian rather than a two-point fit,
-    and it is the reason a single trough can still yield a usable individual
-    estimate.
-    """
-    last_dose_time = (n_doses - 1) * interval
-
-    def predict(eta: np.ndarray, times: np.ndarray) -> np.ndarray:
-        cl = cl_prior * math.exp(eta[0])
-        v = v_prior * math.exp(eta[1])
-        disp = disposition(cl, v)
-        regimen = build_regimen(dose, interval=interval, n_doses=n_doses, duration=infusion)
-        return simulate_linear(times + last_dose_time, regimen, disp)
-
-    times = np.asarray([t for _, t in levels], dtype=float)
-    observed = np.asarray([c for c, _ in levels], dtype=float)
-
-    def objective(eta: np.ndarray) -> float:
-        predicted = predict(eta, times)
-        variance = (model.prop_error * predicted) ** 2 + model.add_error**2
-        residual = float(np.sum((observed - predicted) ** 2 / variance + np.log(variance)))
-        prior = float((eta[0] / model.omega_cl) ** 2 + (eta[1] / model.omega_v) ** 2)
-        return residual + prior
-
-    best = minimize(objective, np.zeros(2), method="Nelder-Mead", options={"xatol": 1e-8, "fatol": 1e-10, "maxiter": 4000})
-    eta = best.x
-    cl = cl_prior * math.exp(eta[0])
-    v = v_prior * math.exp(eta[1])
-    predicted = predict(eta, times)
-    return {
-        "cl_individual": cl,
-        "v_individual": v,
-        "eta_cl": float(eta[0]),
-        "eta_v": float(eta[1]),
-        "cl_fold_vs_population": cl / cl_prior,
-        "v_fold_vs_population": v / v_prior,
-        "half_life": math.log(2.0) * v / cl,
-        "objective": float(best.fun),
-        "predictions": predicted,
-        "observed": observed,
-        "times": times,
-        "converged": bool(best.success),
-    }
-
-
-def exposure_metrics(cl: float, v: float, dose: float, interval: float, infusion: float) -> dict:
-    disp = disposition(cl, v)
-    regimen = build_regimen(dose, interval=interval, n_doses=60, duration=infusion)
-    grid = np.linspace(59 * interval, 60 * interval, 2001)
-    profile = simulate_linear(grid, regimen, disp)
-    auc_tau = float(np.trapezoid(profile, grid))
-    per_day = 24.0 / interval
-    return {
-        "auc_tau": auc_tau,
-        "auc_24h": auc_tau * per_day,
-        "cmax_ss": float(profile.max()),
-        "cmin_ss": float(profile.min()),
-        "cavg_ss": auc_tau / interval,
-    }
-
-
-def recommend_dose(cl: float, target_auc24: float) -> float:
-    """Total daily dose to hit a target AUC24: linear PK makes this exact."""
-    return target_auc24 * cl
-
-
-# --------------------------------------------------------------------- CLI
-
-
-def _level(text: str) -> tuple[float, float]:
-    if "@" not in text:
-        raise argparse.ArgumentTypeError(f"--level must look like 18.2@11.5 (conc@time), got {text!r}")
-    conc_text, time_text = text.split("@", 1)
-    try:
-        conc, time = float(conc_text), float(time_text)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(f"could not parse --level {text!r}") from exc
-    if conc <= 0 or time < 0:
-        raise argparse.ArgumentTypeError("concentration must be positive and time non-negative")
-    return conc, time
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="MAP Bayesian individualisation of a population PK model from measured levels.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    parser.add_argument("--model", choices=sorted(LIBRARY), help="a bundled population model")
-    parser.add_argument("--custom", action="store_true", help="supply population parameters directly")
-    parser.add_argument("--cl-pop", type=float)
-    parser.add_argument("--v-pop", type=float)
-    parser.add_argument("--omega-cl", type=float, default=0.30)
-    parser.add_argument("--omega-v", type=float, default=0.25)
-    parser.add_argument("--prop-error", type=float, default=0.15)
-    parser.add_argument("--add-error", type=float, default=0.5)
-    parser.add_argument("--weight", type=float)
-    parser.add_argument("--crcl", type=float, help="creatinine clearance, mL/min")
-    parser.add_argument("--dose", type=float, required=True)
-    parser.add_argument("--interval", type=float, required=True)
-    parser.add_argument("--infusion", type=float, default=1.0, help="infusion duration, h (default: 1)")
-    parser.add_argument("--doses-given", type=int, default=20, help="doses administered before the levels (default: 20)")
-    parser.add_argument("--level", type=_level, action="append", required=True, help="conc@time-after-last-dose")
-    parser.add_argument("--target-auc24", type=float, help="target AUC24 for a dose recommendation")
-    add_format_argument(parser)
-    return parser
-
-
-def run(argv: Sequence[str] | None = None) -> int:
-    args = build_parser().parse_args(argv)
-    if bool(args.model) == bool(args.custom):
-        raise InputError("choose either --model NAME or --custom")
-    if args.custom:
-        if args.cl_pop is None or args.v_pop is None:
-            raise InputError("--custom needs --cl-pop and --v-pop")
-        model = PopulationModel(
-            name="custom",
-            description="user-supplied population parameters",
-            cl_pop=args.cl_pop,
-            v_pop=args.v_pop,
-            omega_cl=args.omega_cl,
-            omega_v=args.omega_v,
-            prop_error=args.prop_error,
-            add_error=args.add_error,
-            target="",
-            reference="user supplied",
-        )
-        cl_prior, v_prior = args.cl_pop, args.v_pop
-    else:
-        model = LIBRARY[args.model]
-        cl_prior, v_prior = model.individualise(args.weight, args.crcl)
-
-    if args.interval <= 0 or args.dose <= 0:
-        raise InputError("dose and interval must be positive")
-    if args.infusion >= args.interval:
-        raise InputError("infusion duration must be shorter than the dosing interval")
-    for _, time in args.level:
-        if time > args.interval:
-            raise InputError(f"a level at {time} h is beyond the {args.interval} h dosing interval")
-
-    result = map_estimate(
-        model, cl_prior, v_prior, args.dose, args.interval, args.doses_given, args.infusion, args.level
-    )
-
-    report = Report()
-    report.scalar("model", model.name)
-    report.scalar("population_cl", cl_prior)
-    report.scalar("population_v", v_prior)
-    report.scalar("individual_cl", result["cl_individual"])
-    report.scalar("individual_v", result["v_individual"])
-    report.scalar("eta_cl", result["eta_cl"])
-    report.scalar("eta_v", result["eta_v"])
-    report.scalar("individual_half_life", result["half_life"])
-
-    report.table(
-        "observed vs individual prediction",
-        [
-            {
-                "time_after_dose": float(t),
-                "observed": float(o),
-                "predicted": float(p),
-                "residual": float(o - p),
-                "pct_error": 100.0 * (o - p) / o if o else float("nan"),
-            }
-            for t, o, p in zip(result["times"], result["observed"], result["predictions"])
-        ],
-    )
-
-    current = exposure_metrics(result["cl_individual"], result["v_individual"], args.dose, args.interval, args.infusion)
-    report.table("predicted exposure on the current regimen", [{"metric": k, "value": v} for k, v in current.items()])
-
-    if args.target_auc24:
-        daily = recommend_dose(result["cl_individual"], args.target_auc24)
-        per_dose = daily / (24.0 / args.interval)
-        report.scalar("target_auc24", args.target_auc24)
-        report.scalar("recommended_total_daily_dose", daily)
-        report.scalar("recommended_dose_per_interval", per_dose)
-        report.note(
-            "The dose recommendation assumes linear pharmacokinetics, so AUC scales exactly with dose. "
-            "It says nothing about whether the target itself is right for this patient."
-        )
-
-    if abs(result["eta_cl"]) > 2 * model.omega_cl:
-        report.finding(
-            f"the individual clearance is {result['cl_fold_vs_population']:.2f}-fold the population "
-            f"value (eta = {result['eta_cl']:+.2f}, more than 2 omega). Either this patient is genuinely "
-            "atypical, or a level was drawn at a mis-recorded time, or the population model does not "
-            "apply to them. Check the sampling times before acting on the estimate."
-        )
-    if len(args.level) == 1:
-        report.finding(
-            "a single concentration cannot separate clearance from volume; the estimate of whichever "
-            "parameter the sample is uninformative about has simply been pulled back to the population value"
-        )
-    trough_only = all(time > 0.7 * args.interval for _, time in args.level)
-    if trough_only and len(args.level) > 1:
-        report.note(
-            "all levels are late in the interval, so volume is weakly identified. A peak (1-2 h after "
-            "the end of the infusion) plus a trough constrains both parameters."
-        )
-    if not result["converged"]:
-        report.finding("the MAP optimiser did not converge; treat the individual estimates as unreliable")
-
-    if model.target:
-        report.note(f"target: {model.target}")
-    report.note(f"population model provenance: {model.reference}")
-    report.note(
-        "This is a modelling aid, not a dosing decision. Any change to a patient's regimen is the "
-        "responsibility of the treating clinician and depends on the clinical picture, the assay, the "
-        "organism, and local protocol."
-    )
-    return report.emit(args.format)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main_wrapper(run))