palfit 0.1.0__py3-none-any.whl

palfit/__init__.py

@@ -0,0 +1,7 @@
+"""Fit a physical activity level (PAL) to an observed weight trajectory with Hall's adult model."""
+
+from palfit._fit import FitResult, fit_pal
+from palfit._model import Trajectory, simulate
+
+__version__ = "0.1.0"
+__all__ = ["FitResult", "Trajectory", "__version__", "fit_pal", "simulate"]

palfit/_fit.py

@@ -0,0 +1,128 @@
+"""Invert the Hall model: observed weights -> the PAL that reproduces them."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Sequence
+
+from palfit._model import (
+    Trajectory,
+    simulate,
+    validate_intake,
+    validate_person,
+)
+
+_INVPHI = (math.sqrt(5) - 1) / 2
+
+
+@dataclass(frozen=True)
+class FitResult:
+    pal: float
+    maintenance_kcal: float  # mean model expenditure over the last ``tail_days``
+    sse_kg2: float
+    n_obs: int
+    hit_lower: bool  # optimum pinned at the lower bound: the fit is not trustworthy
+    hit_upper: bool
+    trajectory: Trajectory
+
+
+def _observed(observed_kg: Sequence[Optional[float]], n: int) -> list[Optional[float]]:
+    if len(observed_kg) != n:
+        raise ValueError("intake_kcal and observed_kg must be the same length")
+    out: list[Optional[float]] = []
+    for i, v in enumerate(observed_kg):
+        if v is None:
+            out.append(None)
+            continue
+        if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or v <= 0:
+            raise ValueError(f"observed_kg[{i}] must be None or a positive finite number, got {v!r}")
+        out.append(float(v))
+    return out
+
+
+def fit_pal(
+    *,
+    height_m: float,
+    age_years: float,
+    sex: str,
+    start_weight_kg: float,
+    intake_kcal: Sequence[float],
+    observed_kg: Sequence[Optional[float]],
+    fat0_kg: Optional[float] = None,
+    carb_fraction: float = 0.5,
+    baseline_carb_fraction: float = 0.5,
+    lo: float = 1.1,
+    hi: float = 2.5,
+    tol: float = 1e-4,
+    tail_days: int = 7,
+) -> FitResult:
+    """Golden-section search for the PAL whose simulated weight best matches ``observed_kg``.
+
+    ``observed_kg[i]`` is ``None`` on days without a reading. ``intake_kcal`` must
+    have no gaps. At least two observations are required; with none the error
+    surface is flat and a search would silently return a bound.
+
+    ``hit_lower`` / ``hit_upper`` are set when the optimum lies within ``10 * tol``
+    of a bound; treat such a result as "the data cannot be explained", not as an
+    estimate.
+    """
+    if not 0 < tol < 1:
+        raise ValueError("tol must be in (0, 1)")
+    if not 0 < lo < hi:
+        raise ValueError("need 0 < lo < hi")
+    if not isinstance(tail_days, int) or tail_days < 1:
+        raise ValueError("tail_days must be a positive integer")
+    validate_person(height_m, age_years, sex, start_weight_kg, fat0_kg)
+    validate_intake(intake_kcal)
+    obs = _observed(observed_kg, len(intake_kcal))
+    n_obs = sum(o is not None for o in obs)
+    if n_obs < 2:
+        raise ValueError(f"need at least 2 observed weights, got {n_obs}")
+
+    def run(pal: float) -> Trajectory:
+        return simulate(
+            height_m=height_m,
+            age_years=age_years,
+            sex=sex,
+            start_weight_kg=start_weight_kg,
+            pal=pal,
+            intake_kcal=intake_kcal,
+            fat0_kg=fat0_kg,
+            carb_fraction=carb_fraction,
+            baseline_carb_fraction=baseline_carb_fraction,
+        )
+
+    def sse(traj: Trajectory) -> float:
+        total = sum((s - o) ** 2 for s, o in zip(traj.weight_kg, obs) if o is not None)
+        return total if math.isfinite(total) else math.inf
+
+    def cost(pal: float) -> float:
+        return sse(run(pal))
+
+    a, b = lo, hi
+    c = b - _INVPHI * (b - a)
+    d = a + _INVPHI * (b - a)
+    fc, fd = cost(c), cost(d)
+    while abs(b - a) > tol:
+        if fc < fd:
+            b, d, fd = d, c, fc
+            c = b - _INVPHI * (b - a)
+            fc = cost(c)
+        else:
+            a, c, fc = c, d, fd
+            d = a + _INVPHI * (b - a)
+            fd = cost(d)
+    pal = (a + b) / 2
+    traj = run(pal)
+    tail = traj.expenditure_kcal[-tail_days:]
+    eps = 10 * tol
+    return FitResult(
+        pal=pal,
+        maintenance_kcal=sum(tail) / len(tail),
+        sse_kg2=sse(traj),
+        n_obs=n_obs,
+        hit_lower=pal <= lo + eps,
+        hit_upper=pal >= hi - eps,
+        trajectory=traj,
+    )

palfit/_model.py

@@ -0,0 +1,234 @@
+"""Hall adult body-weight ODE, forward simulation.
+
+Equations and constants are transcribed from INSP-RH/bw ``src/adult_weight.cpp``
+(MIT, see NOTICE). Intake forcing follows upstream exactly: upstream reads the
+intake change as ``EIchange[floor(t / dt)]``, so within the RK4 step from day
+i-1 to day i the stages k1-k3 (t = i-1, i-1/2) see day i-1's value and only k4
+(t = i) sees day i's.
+
+Deliberate deviation from upstream: when the baseline-day carbohydrate intake
+is zero, the carb/sodium coupling term of the ECF equation is dropped instead
+of dividing by zero (upstream and ``hallmodel`` return NaN there).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Sequence
+
+# Units: energy kcal, mass kg, sodium mg. Verbatim from Adult::getParameters().
+ROG = 4206.501  # kcal/kg glycogen
+NA_CONST = 3220.0
+ZETA_NA = 3000.0
+ZETA_CI = 4000.0
+ROF = 9440.727  # kcal/kg fat
+ROL = 1816.444  # kcal/kg lean tissue
+GAMMA_F = 3.107075
+GAMMA_L = 21.98853
+ETA_F = 179.2543
+ETA_L = 229.4455
+BETA_TEF = 0.1
+BETA_AT = 0.14
+TAU_AT = 14.0  # days
+C_CONST = 10.4 * (ROL / ROF)
+ALFA1 = -(1.0 + ETA_L / ROL) * C_CONST
+ALFA2 = -(1.0 + ETA_F / ROF)
+G_BASE_KG = 0.5
+GLYCOGEN_WATER = 3.7  # kg of glycogen + bound water per kg glycogen
+
+# Mifflin-St Jeor, as in Adult::getRMR.
+_RMR_BW, _RMR_HT, _RMR_AGE, _RMR_M, _RMR_F = 9.99, 625.0, 4.92, 5.0, 161.0
+
+SEXES = ("male", "female")
+
+
+@dataclass(frozen=True)
+class Trajectory:
+    """Day-indexed model output; index 0 is the initial condition."""
+
+    pal: float
+    rmr_kcal: float
+    baseline_expenditure_kcal: float  # RMR * PAL, the steady-state expenditure
+    weight_kg: tuple[float, ...]
+    fat_kg: tuple[float, ...]
+    lean_kg: tuple[float, ...]
+    glycogen_kg: tuple[float, ...]  # glycogen only; its bound water is in weight_kg
+    ecf_kg: tuple[float, ...]
+    adaptive_thermogenesis_kcal: tuple[float, ...]
+    expenditure_kcal: tuple[float, ...]
+
+
+def _finite(name: str, x: float) -> float:
+    if isinstance(x, bool) or not isinstance(x, (int, float)) or not math.isfinite(x):
+        raise ValueError(f"{name} must be a finite number, got {x!r}")
+    return float(x)
+
+
+def validate_person(
+    height_m: float,
+    age_years: float,
+    sex: str,
+    start_weight_kg: float,
+    fat0_kg: Optional[float],
+) -> None:
+    if sex not in SEXES:
+        raise ValueError(f"sex must be one of {SEXES}, got {sex!r}")
+    if not 0.5 <= _finite("height_m", height_m) <= 2.5:
+        raise ValueError(f"height_m must be in metres (0.5-2.5), got {height_m}")
+    if _finite("age_years", age_years) < 18:
+        raise ValueError("this is the adult model: age_years must be >= 18")
+    if _finite("start_weight_kg", start_weight_kg) <= 0:
+        raise ValueError("start_weight_kg must be positive")
+    if fat0_kg is not None and not 0 < _finite("fat0_kg", fat0_kg) < start_weight_kg:
+        raise ValueError("fat0_kg must be between 0 and start_weight_kg")
+
+
+def validate_intake(intake_kcal: Sequence[float]) -> None:
+    if len(intake_kcal) < 2:
+        raise ValueError("need at least 2 days of intake to integrate")
+    for i, v in enumerate(intake_kcal):
+        if v is None:
+            raise ValueError(f"intake_kcal[{i}] is None: fill intake gaps before calling")
+        if _finite(f"intake_kcal[{i}]", v) < 0:
+            raise ValueError(f"intake_kcal[{i}] is negative")
+
+
+def rmr_kcal(weight_kg: float, height_m: float, age_years: float, sex: str) -> float:
+    base = _RMR_BW * weight_kg + _RMR_HT * height_m -_RMR_AGE * age_years
+    return base + _RMR_M if sex == "male" else base - _RMR_F
+
+
+def _ecf_init(bw: float, ht: float, age: float, sex: str) -> float:
+    """Silva's equation, Adult::getECFinit."""
+    if sex == "male":
+        return 0.025 * age + 9.57 * ht + 0.191 * bw - 12.4
+    return -4.0 + 5.98 * ht + 0.167 * bw
+
+
+def _baseline_fat_kg(bw: float, ht: float, age: float, sex: str) -> float:
+    """Adult::getBaselineMass; used only when no measured fat mass is given."""
+    bmi = bw / ht**2
+    if sex == "male":
+        pct = 0.14 * age + 37.31 * math.log(bmi) - 103.94
+    else:
+        pct = 0.14 * age + 39.96 * math.log(bmi) - 102.01
+    return bw * pct / 100.0
+
+
+def simulate(
+    *,
+    height_m: float,
+    age_years: float,
+    sex: str,
+    start_weight_kg: float,
+    pal: float,
+    intake_kcal: Sequence[float],
+    fat0_kg: Optional[float] = None,
+    carb_fraction: float = 0.5,
+    baseline_carb_fraction: float = 0.5,
+) -> Trajectory:
+    """Run the model forward, one step per entry of ``intake_kcal``.
+
+    ``intake_kcal[0]`` is the baseline (energy-balance) intake. The model starts
+    on day 0 at ``start_weight_kg`` with zero adaptive thermogenesis and
+    expenditure equal to ``RMR * pal``.
+    """
+    validate_person(height_m, age_years, sex, start_weight_kg, fat0_kg)
+    validate_intake(intake_kcal)
+    if not 0.0 < _finite("pal", pal) < 5.0:
+        raise ValueError(f"pal must be in (0, 5), got {pal}")
+    for nm, v in (("carb_fraction", carb_fraction), ("baseline_carb_fraction", baseline_carb_fraction)):
+        if not 0.0 <= _finite(nm, v) <= 1.0:
+            raise ValueError(f"{nm} must be in [0, 1]")
+
+    bw0, ht, age = float(start_weight_kg), float(height_m), float(age_years)
+    n = len(intake_kcal)
+    ei0 = float(intake_kcal[0])
+
+    rmr = rmr_kcal(bw0, ht, age, sex)
+    ecf_init = _ecf_init(bw0, ht, age, sex)
+    fat_base = float(fat0_kg) if fat0_kg is not None else _baseline_fat_kg(bw0, ht, age, sex)
+    lean_base = bw0 - (ecf_init + fat_base + GLYCOGEN_WATER * G_BASE_KG)
+    if lean_base <= 0 or fat_base <= 0:
+        raise ValueError("inputs imply non-positive fat or lean mass; check units and fat0_kg")
+    delta = ((1.0 - BETA_TEF) * pal - 1.0) * rmr / bw0
+    k_const = rmr * pal - GAMMA_L * lean_base - GAMMA_F * fat_base - delta * bw0
+    cib = baseline_carb_fraction * ei0
+    kg_const = cib / (G_BASE_KG**2)
+    delta_ei = [float(v) - ei0 for v in intake_kcal]
+
+    def fat_of(lean: float) -> float:
+        return fat_base * math.exp(ROL * (lean - lean_base) / (ROF * C_CONST))
+
+    def d_g(g: float, dei: float) -> float:
+        return (carb_fraction * (ei0 + dei) - kg_const * g * g) / ROG
+
+    def d_at(at: float, dei: float) -> float:
+        return (BETA_AT * dei - at) / TAU_AT
+
+    def d_ecf(ecf: float, dei: float) -> float:
+        ci = carb_fraction * (ei0 + dei)
+        ci_term = ZETA_CI * (1.0 - ci / cib) if cib else 0.0
+        return (-ZETA_NA * (ecf - ecf_init) - ci_term) / NA_CONST
+
+    def d_l(lean: float, g: float, at: float, ecf: float, dei: float) -> float:
+        fat = fat_of(lean)
+        weight = lean + fat + ecf + GLYCOGEN_WATER * g
+        r3 = k_const + delta * weight + BETA_TEF * dei + at - (ei0 + dei) + ROG * d_g(g, dei)
+        r = (r3 + GAMMA_L * lean + GAMMA_F * fat) / (ALFA1 + ALFA2 * fat)
+        return r * (C_CONST / ROL)
+
+    def expenditure(lean: float, fat: float, ecf: float, g: float, at: float, dei: float) -> float:
+        weight = lean + fat + ecf + GLYCOGEN_WATER * g
+        return k_const + GAMMA_L * lean + GAMMA_F * fat + delta * weight + BETA_TEF * dei + at
+
+    def rk4(f, y: float, dei_a: float, dei_b: float) -> float:
+        # k1-k3 evaluated at t = i-1 (+ half step): previous day's forcing; k4 at t = i.
+        k1 = f(y, dei_a)
+        k2 = f(y + 0.5 * k1, dei_a)
+        k3 = f(y + 0.5 * k2, dei_a)
+        k4 = f(y + k3, dei_b)
+        return y + (k1 + 2 * k2 + 2 * k3 + k4) / 6.0
+
+    at = [0.0] * n
+    ecf = [ecf_init] * n
+    g = [G_BASE_KG] * n
+    lean = [lean_base] * n
+    fat = [fat_base] * n
+    bw = [bw0] * n
+    ee = [0.0] * n
+    ee[0] = expenditure(lean[0], fat[0], ecf[0], g[0], at[0], delta_ei[0])
+
+    for i in range(1, n):
+        da, db = delta_ei[i - 1], delta_ei[i]
+        at[i] = rk4(d_at, at[i - 1], da, db)
+        ecf[i] = rk4(d_ecf, ecf[i - 1], da, db)
+        g[i] = rk4(d_g, g[i - 1], da, db)
+
+        g_avg = 0.5 * (g[i] + g[i - 1])
+        at_avg = 0.5 * (at[i] + at[i - 1])
+        ecf_avg = 0.5 * (ecf[i] + ecf[i - 1])
+        y = lean[i - 1]
+        k1 = d_l(y, g[i - 1], at[i - 1], ecf[i - 1], da)
+        k2 = d_l(y + 0.5 * k1, g_avg, at_avg, ecf_avg, da)
+        k3 = d_l(y + 0.5 * k2, g_avg, at_avg, ecf_avg, da)
+        k4 = d_l(y + k3, g[i], at[i], ecf[i], db)
+        lean[i] = y + (k1 + 2 * k2 + 2 * k3 + k4) / 6.0
+
+        fat[i] = fat_of(lean[i])
+        bw[i] = fat[i] + lean[i] + ecf[i] + GLYCOGEN_WATER * g[i]
+        ee[i] = expenditure(lean[i], fat[i], ecf[i], g[i], at[i], db)
+
+    return Trajectory(
+        pal=float(pal),
+        rmr_kcal=rmr,
+        baseline_expenditure_kcal=rmr * pal,
+        weight_kg=tuple(bw),
+        fat_kg=tuple(fat),
+        lean_kg=tuple(lean),
+        glycogen_kg=tuple(g),
+        ecf_kg=tuple(ecf),
+        adaptive_thermogenesis_kcal=tuple(at),
+        expenditure_kcal=tuple(ee),
+    )

palfit-0.1.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.5
+Name: palfit
+Version: 0.1.0
+Summary: Fit a physical activity level (PAL) and maintenance calories to a weight log with Hall's adult body-weight model. Pure Python, no dependencies.
+Project-URL: Homepage, https://github.com/112345brian/palfit
+Project-URL: Repository, https://github.com/112345brian/palfit
+Project-URL: Issues, https://github.com/112345brian/palfit/issues
+Author: 112345brian
+License-Expression: MIT
+License-File: LICENSE
+License-File: NOTICE
+Keywords: Hall model,PAL,TDEE,body weight,energy balance,maintenance calories
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: parity
+Requires-Dist: hallmodel; extra == 'parity'
+Requires-Dist: numpy; extra == 'parity'
+Requires-Dist: pytest>=8; extra == 'parity'
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# palfit
+
+Fit a **physical activity level (PAL)**, and from it a maintenance-calorie estimate, to a daily intake log and a gappy body-weight log, using Kevin Hall's adult dynamic body-weight model. Pure Python, no runtime dependencies.
+
+The forward model is a port of the R package [INSP-RH/bw](https://github.com/INSP-RH/bw) (MIT). The compiled PyPI package `hallmodel` offers the same forward model; **neither it nor `bw` fits PAL to data**. That inversion is what this package adds. See `NOTICE`.
+
+Source and issues: https://github.com/112345brian/palfit
+
+## Install
+
+```bash
+pip install palfit
+```
+
+## Use
+
+```python
+import palfit
+
+result = palfit.fit_pal(
+    height_m=1.78, age_years=32, sex="male",
+    start_weight_kg=85.0,
+    intake_kcal=intake,        # one value per day, no gaps; intake[0] is the baseline day
+    observed_kg=weights,       # same length; None on days without a reading
+)
+
+if result.hit_lower or result.hit_upper:
+    print("PAL pinned at a bound: the weights cannot be explained by this model")
+print(result.pal, result.maintenance_kcal)
+result.trajectory.fat_kg, .lean_kg, .glycogen_kg, .ecf_kg, .weight_kg, .expenditure_kcal
+```
+
+* `fit_pal(*, height_m, age_years, sex, start_weight_kg, intake_kcal, observed_kg, fat0_kg=None, carb_fraction=0.5, baseline_carb_fraction=0.5, lo=1.1, hi=2.5, tol=1e-4, tail_days=7) -> FitResult`
+* `simulate(*, height_m, age_years, sex, start_weight_kg, pal, intake_kcal, fat0_kg=None, carb_fraction=0.5, baseline_carb_fraction=0.5) -> Trajectory`
+* `FitResult`: `pal`, `maintenance_kcal`, `sse_kg2`, `n_obs`, `hit_lower`, `hit_upper`, `trajectory`. Frozen dataclasses of tuples.
+* Raises `ValueError` for: unknown sex, age under 18, height not in metres, non-finite or negative values, `None` in intake, length mismatch, fewer than 2 observed weights, `fat0_kg` outside (0, weight).
+* No file, database, network or global state; inputs are never mutated.
+
+## What PAL means here
+
+PAL = total daily energy expenditure divided by resting metabolic rate (RMR, Mifflin-St Jeor from the **start weight**). `fit_pal` searches PAL in `[lo, hi]` (golden section) to minimise the squared difference between simulated and observed weights.
+
+* `maintenance_kcal` is the model's expenditure averaged over the **last `tail_days` of the simulated period**, which includes the model's adaptive-thermogenesis and thermic-effect terms for that period. It is not simply `RMR * PAL` (that value is `trajectory.baseline_expenditure_kcal`, the steady-state figure at the start).
+* The model does **not** assume day-0 intake equals expenditure. Day 0 is the model's "energy balance" reference for deviations (`intake - intake[0]`), and PAL is free. Pick a typical day as `intake[0]`, not a fast day or a feast.
+* Glycogen is reported as glycogen only; its bound water (3.7 kg per kg glycogen) is inside `weight_kg`.
+
+## Limitations (read these)
+
+* **Garbage in, garbage out on intake.** Logged intake that is 10% low or high moves the estimated maintenance by about -240 / +240 kcal in the test case below. The fit cannot tell a bad log from a different metabolism.
+* **The start weight is treated as exact.** A start weight off by 0.5 kg shifted the fit by about 0.03 PAL (about 50 kcal) in the test case. Use a smoothed or averaged start value.
+* **Short windows are noisy.** In the synthetic study, 28 days with 0.4 kg noise gave an RMSE of about 0.027 PAL (roughly 50 kcal).
+* **Flat error surface is not detected.** With almost no intake variation or a very short window, many PALs fit about equally well and the optimum is poorly determined. Only hitting a bound is flagged.
+* Adult model only; daily steps only; sodium input not supported; no uncertainty interval.
+* Not medical advice. The model is a published population-level approximation; this package has been tested against that model, **not against measured individuals**.
+
+## What is verified, and how
+
+Everything below was run on macOS arm64 with `hallmodel==2026.10.21.16`. "Not verified" items are listed explicitly.
+
+| Claim | Evidence |
+|---|---|
+| `simulate` equals `hallmodel.adult_weight` on 7 scenarios (steady, carb surge, cut, female bulk, high PAL, long refeed, noisy week) | Test tolerances 1e-9 kg and 1e-6 kcal on all series; measured worst case on the carb-surge scenario: 0.0 kg weight, 4.5e-13 kcal expenditure |
+| Intake forcing matches upstream C++ (`EIchange[floor(t/dt)]`: RK4 stages k1-k3 use the previous day's value, k4 the current day's) | Read from `adult_weight.cpp`; a port using the current day in all stages differed from `hallmodel` by up to 0.43 kg and 12 kcal before the change |
+| PAL recovery on model-generated data (truth 1.72, 90 days, 0.15 kg noise, a third of days missing, 30 seeds) | bias 0.0002, RMSE 0.0015, worst error 0.003 PAL |
+| Same, 28 days / 56 days, 0.15 kg noise | RMSE 0.0102 / 0.0036 PAL |
+| Energy balance closes to within the model's tissue-efficiency losses | stored/net ratio 0.96-0.97 over 30-365 days (a test guards 0.93-1.0) |
+| Zero baseline intake gives finite output | tested; this deliberately differs from upstream/`hallmodel`, which return NaN |
+
+**Not verified:** agreement with the R package itself (R was not run; the claim rests on the C++ source and `hallmodel`); correctness of `hallmodel`'s own parity claim (its upstream "contract" branch is not publicly visible); behaviour on Python 3.11 and on non-macOS platforms; real-world accuracy against measured expenditure (doubly labelled water or similar); PAL uncertainty estimates; unimodality of the error surface over `[1.1, 2.5]` beyond the cases above.
+
+## Development
+
+```bash
+pip install -e '.[test]'          # unit tests, no network or data needed
+pip install -e '.[parity]'        # adds numpy + hallmodel for the dev-only parity tests
+pytest
+```
+
+## Before release
+
+Run `python tools/check_release.py`; it fails while any placeholder marker remains in `LICENSE`, `NOTICE`, `README.md` or `pyproject.toml`, or if `authors` is missing. Re-check that the distribution name is unclaimed on PyPI immediately before uploading.
+
+## Licence
+
+MIT. Model code derived from INSP-RH/bw (MIT, Instituto Nacional de Salud Pública); see `LICENSE` and `NOTICE`.

palfit-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+palfit/__init__.py,sha256=Wz4yNR1G3dvJv8MuTWugKayt4CwMc1cqsoa_PXroBH0,290
+palfit/_fit.py,sha256=GNQtXP74GmMdIPo448qpnuQvNUIo-xqSa9R503S-PgM,4052
+palfit/_model.py,sha256=-PNQKCzgSdbKWrRMQ6_2xPY_Q6IvFV3f6hwaMNjd__g,8845
+palfit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palfit-0.1.0.dist-info/METADATA,sha256=Jx2UMlXUr2wcXkONDSWHHuqtqqaao213xGYHDDnOKzw,7447
+palfit-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+palfit-0.1.0.dist-info/licenses/LICENSE,sha256=lpxTl9nZ175fydExAGEOEJrF3GbUIGLvIqsbJywg0Fw,1186
+palfit-0.1.0.dist-info/licenses/NOTICE,sha256=pB2wxAHN3dDtGH2cveB_F4f2LAhH_PKJ7crNrpSxd0g,2468
+palfit-0.1.0.dist-info/RECORD,,

palfit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

palfit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018 Instituto Nacional de Salud Pública (INSP-RH/bw, from which the model code is ported; see NOTICE)
+Copyright (c) 2026 112345brian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

palfit-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,44 @@
+NOTICE / ATTRIBUTION
+
+This package is a derivative work. Its model code (src/palfit/_model.py) is a
+Python port of the adult model in the R package INSP-RH/bw
+(https://github.com/INSP-RH/bw), file src/adult_weight.cpp. Equations, constants,
+and the order of operations are transcribed from that file; they were not re-derived.
+
+Upstream copyright and licence
+  Copyright (c) 2018 Instituto Nacional de Salud Pública (México)
+  Licensed under the MIT licence (DESCRIPTION: "MIT + file LICENSE"; the full MIT
+  text is in the header of the upstream C++ files). The MIT text is reproduced in
+  this package's LICENSE file.
+  Upstream authors named in the source headers: Dalia Camacho-García-Formentí,
+  Rodrigo Zepeda-Tello.
+
+What is original here (not in bw)
+  - The inversion (fit_pal): golden-section search over PAL against observed weights.
+  - Bound-hit flags, input validation, the all-missing-weights guard.
+  - The guard that drops the carbohydrate/sodium term of the ECF equation when the
+    baseline-day carbohydrate intake is zero (upstream returns NaN there).
+  - Tests, including parity tests against the `hallmodel` package (dev-only).
+
+What is not ported
+  - The child model, sodium-driven ECF changes (the sodium input is fixed at zero
+    change), multi-individual matrices, intake interpolation (energy_build), and
+    non-daily time steps.
+
+Scientific sources of the model (as cited in the upstream source header)
+  Chow, C.C. and Hall, K.D. (2008). The Dynamics of Human Body Weight Change.
+    PLoS Comput Biol 4(3): e1000045.
+  Hall, K.D. (2010). Predicting Metabolic Adaptation, Body Weight Change, and Energy
+    Intake in Humans. Am J Physiol Endocrinol Metab 298(3): E449-E466.
+  Hall, K.D. and Jordan, P.N. (2008). Modeling Weight-Loss Maintenance to Help
+    Prevent Body Weight Regain. Am J Clin Nutr 88(6): 1495-1503.
+  Hall, K.D., Sacks, G., Chandramohan, D., Chow, C.C., Wang, Y.C., Gortmaker, S.L.,
+    Swinburn, B.A. (2011). Quantification of the Effect of Energy Imbalance on
+    Bodyweight. The Lancet 378(9793): 826-837.
+  Mifflin, M.D., St Jeor, S.T., Hill, L.A., Scott, B.J., Daugherty, S.A., Koh, Y.O.
+    (1990). A New Predictive Equation for Resting Energy Expenditure in Healthy
+    Individuals. Am J Clin Nutr 51(2): 241-247.
+
+Related software (used only as a test-time reference, never vendored)
+  `hallmodel` on PyPI (compiled C++ binding of the same upstream model, MIT).
+  https://github.com/ChocoTonic/hallmodel-py