Address local AI review (Wave 2): exact dose-invariance, tolerance-aware integer detection

P1 from local review (`treatment_dose.is_time_invariant`):
- Removed `np.round(..., 8)` tolerance from `_compute_treatment_dose`'s
  per-unit non-zero distinct-count check. The documented contract is
  "per-unit non-zero doses have at most one distinct value" (exact),
  but the implementation was rounding to 8 decimals before comparing,
  silently classifying tiny-but-real dose variation as time-invariant
  and contradicting the docstring + CHANGELOG + autonomous guide §2.
  Now uses exact `np.unique(unit_nonzero).size > 1`. Added a regression
  test (`test_treatment_dose_distinguishes_doses_at_high_precision`) for
  a unit with two non-equal doses separated by 1e-9 (sub the previous
  rounding window) — asserts `is_time_invariant=False`.

Related dead-code removal:
- Removed the `len(nonzero) == 0` defensive branch in
  `_compute_treatment_dose`. `treatment_type == "continuous"` is reached
  only when the treatment column has more than two distinct values OR
  a 2-valued numeric outside `{0, 1}`; an all-zero numeric column is
  classified as `binary_absorbing` and never reaches this branch, so
  `nonzero` is guaranteed non-empty. Removing the branch eliminates
  the NaN-vs-Optional[float] inconsistency the reviewer flagged on
  `dose_min/max/mean`.

P2 from local review (`is_integer_valued` brittleness):
- Switched from `np.equal(np.mod(arr, 1.0), 0.0)` to
  `np.isclose(arr, np.round(arr), rtol=0.0, atol=1e-12)`. The treatment
  / outcome column is user input (system boundary), and CSV-roundtripped
  count columns commonly carry float64 representation noise (e.g.,
  `1.0` stored as `1.0000000000000002`). Tolerance-aware integer
  detection is the right discipline at the boundary; downstream the
  `is_count_like` heuristic remains gated on this AND `pct_zeros > 0`
  AND `skewness > 0.5` AND `n_distinct > 2`, so isolated noise can't
  flip the classification.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: igerber

diff_diff/profile.py

@@ -613,7 +613,11 @@ def _compute_outcome_shape(valid: pd.Series, outcome_dtype_kind: str) -> Optiona
     value_min = float(arr.min())
     value_max = float(arr.max())
 
-    is_integer_valued = bool(np.all(np.equal(np.mod(arr, 1.0), 0.0)))
+    # Tolerance-aware integer detection: a CSV-roundtripped count column
+    # may carry float64 representation noise (e.g., 1.0 stored as
+    # 1.0000000000000002), and that should still classify as
+    # integer-valued for the purpose of the count-like heuristic.
+    is_integer_valued = bool(np.all(np.isclose(arr, np.round(arr), rtol=0.0, atol=1e-12)))
     is_bounded_unit = bool(np.all((arr >= 0.0) & (arr <= 1.0)))
 
     skewness: Optional[float] = None
@@ -672,24 +676,28 @@ def _compute_treatment_dose(
     n_distinct_doses = int(col.nunique())
     has_zero_dose = bool((col == 0).any())
 
+    # `treatment_type == "continuous"` is reached only when the
+    # treatment column has more than two distinct values OR a 2-valued
+    # numeric outside `{0, 1}` (see `_classify_treatment`). An all-zero
+    # numeric column is classified as `binary_absorbing` and never
+    # reaches this branch, so `nonzero` is guaranteed non-empty.
     nonzero = col[col != 0]
-    if len(nonzero) > 0:
-        dose_min = float(nonzero.min())
-        dose_max = float(nonzero.max())
-        dose_mean = float(nonzero.mean())
-    else:
-        dose_min = float("nan")
-        dose_max = float("nan")
-        dose_mean = float("nan")
+    dose_min = float(nonzero.min())
+    dose_max = float(nonzero.max())
+    dose_mean = float(nonzero.mean())
 
     is_time_invariant = True
     for _, group in df.groupby(unit, sort=False):
         unit_doses = group[treatment].dropna().to_numpy()
         unit_nonzero = unit_doses[unit_doses != 0]
         if len(unit_nonzero) == 0:
             continue
-        rounded = np.round(unit_nonzero.astype(float), 8)
-        if int(np.unique(rounded).size) > 1:
+        # Exact distinct-count on observed non-zero values, matching the
+        # documented contract "per-unit non-zero doses have at most one
+        # distinct value." No tolerance is applied: continuous-DiD
+        # eligibility is gated downstream by `ContinuousDiD.fit()`,
+        # which itself uses exact equality on the dose column.
+        if int(np.unique(unit_nonzero).size) > 1:
             is_time_invariant = False
             break
 

tests/test_profile_panel.py

@@ -1075,6 +1075,37 @@ def test_treatment_dose_continuous_time_varying_within_unit():
     assert dose.is_time_invariant is False
 
 
+def test_treatment_dose_distinguishes_doses_at_high_precision():
+    """`is_time_invariant` uses EXACT distinct-count on observed non-zero
+    doses; a unit with two non-equal doses must be flagged as
+    time-varying even when the values differ only at sub-1e-8 precision.
+    Guards against an earlier implementation that rounded to 8 decimals
+    before comparing, silently treating tiny-but-real dose variation as
+    time-invariant. Required by the documented contract "per-unit
+    non-zero doses have at most one distinct value."""
+    rows = []
+    for u in range(1, 21):
+        for t in range(4):
+            if u <= 5:
+                dose = 0.0
+            elif u == 10:
+                # Unit 10 has two distinct nonzero doses separated by
+                # 1e-9 - smaller than the previous 1e-8 rounding window.
+                dose = 2.5 if t < 2 else 2.5 + 1e-9
+            else:
+                dose = 2.5
+            rows.append({"u": u, "t": t, "tr": dose, "y": 0.0})
+    df = pd.DataFrame(rows)
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    dose = profile.treatment_dose
+    assert dose is not None
+    assert dose.is_time_invariant is False, (
+        "Expected is_time_invariant=False for a unit with non-equal "
+        "non-zero doses, even at sub-1e-8 precision; the field's "
+        "documented contract is exact distinct-count on observed values."
+    )
+
+
 def test_treatment_dose_continuous_no_zero_dose():
     """If every unit has a strictly positive dose throughout, has_zero_dose
     must be False — flagging the absence of zero-dose controls required by