Fix profile_panel() binary detection for degenerate panels

The treatment classifier required exactly two observed distinct values
to treat a column as binary. Panels that are entirely never-treated
(values = {0}) or entirely always-treated (values = {1}) were falling
through to "continuous", contradicting the documented taxonomy which
defines "binary_absorbing" as "values in {0, 1}".

Rule is now values_set <= {0, 1, 0.0, 1.0} with at least one observed
value; entirely-NaN treatment columns fall through to "categorical"
rather than "continuous". Docstring and the autonomous guide section
§2 reference are updated to match.

New regression tests:
- all-zero treatment panel -> binary_absorbing, has_never_treated
- all-one treatment panel -> binary_absorbing, has_always_treated
- binary with NaNs, only zeros observed -> binary_absorbing
- all-NaN treatment -> categorical
- top-level import surface (profile_panel / PanelProfile / Alert)

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

Author: igerber

diff_diff/guides/llms-autonomous.txt

@@ -74,19 +74,24 @@ view. Every field below appears as a top-level key in that dict.
 
 - **`treatment_type: str`** - classification of the treatment column.
   Exactly one of:
-    - `"binary_absorbing"`: numeric with values in {0, 1}; each unit's
-      treatment sequence (ordered by `time`) is weakly monotone
-      non-decreasing. The canonical DiD setting.
-    - `"binary_non_absorbing"`: values in {0, 1} but at least one unit
-      switches from 1 back to 0. Only `ChaisemartinDHaultfoeuille` handles
-      this natively; the other absorbing-only estimators would misapply.
-    - `"continuous"`: numeric with more than two distinct values (e.g., a
-      dose, a discrete-integer partial-adoption score). Use
+    - `"binary_absorbing"`: observed non-NaN values are a subset of
+      {0, 1} (one or two distinct values, covering all-zero and all-one
+      panels as valid degenerate cases) and each unit's treatment
+      sequence (ordered by `time`) is weakly monotone non-decreasing.
+      The canonical DiD setting.
+    - `"binary_non_absorbing"`: values a subset of {0, 1} with at least
+      two distinct values observed, where at least one unit switches
+      from 1 back to 0. Only `ChaisemartinDHaultfoeuille` handles this
+      natively; the other absorbing-only estimators would misapply.
+    - `"continuous"`: numeric with more than two distinct values, or a
+      two-valued numeric column whose values are not in {0, 1} (e.g.,
+      a dose, a discrete-integer partial-adoption score). Use
       `ContinuousDiD` or `HeterogeneousAdoptionDiD`.
-    - `"categorical"`: non-numeric dtype (object / category) or bool dtype.
-      Often indicates a treatment arm. Encode each arm as a binary
-      indicator and fit separately, or use a multi-treatment workflow
-      outside the current estimator suite.
+    - `"categorical"`: non-numeric dtype (object / category), a bool
+      dtype column, or a column that is entirely NaN. Often indicates
+      a treatment arm. Encode each arm as a binary indicator and fit
+      separately, or use a multi-treatment workflow outside the
+      current estimator suite.
 - **`is_staggered: bool`** - true iff treatment is `binary_absorbing` and
   at least two distinct first-treatment periods are observed. Drives the
   choice between classic DiD/TWFE and staggered-robust estimators.

diff_diff/profile.py

@@ -172,15 +172,23 @@ def profile_panel(
     -----
     Classification rules for ``treatment_type``:
 
-    - ``"binary_absorbing"``: numeric treatment taking values in :math:`\\{0, 1\\}`
-      where each unit's treatment sequence (ordered by ``time``) is weakly
-      monotone non-decreasing.
-    - ``"binary_non_absorbing"``: values in :math:`\\{0, 1\\}` but at least
-      one unit switches from 1 back to 0.
+    - ``"binary_absorbing"``: numeric treatment whose observed non-NaN
+      values are a subset of :math:`\\{0, 1\\}` (one or two distinct
+      values) AND each unit's treatment sequence (ordered by ``time``)
+      is weakly monotone non-decreasing. All-zero and all-one panels
+      are valid degenerate cases.
+    - ``"binary_non_absorbing"``: values a subset of :math:`\\{0, 1\\}`
+      with at least two distinct values observed, where at least one
+      unit switches from 1 back to 0.
     - ``"continuous"``: numeric treatment with more than two distinct
-      values (matches the ``ContinuousDiD`` convention).
-    - ``"categorical"``: non-numeric dtype (object / category) or a
-      boolean-dtype column.
+      values, or a 2-valued numeric whose values are not in
+      :math:`\\{0, 1\\}` (matches the ``ContinuousDiD`` convention).
+    - ``"categorical"``: non-numeric dtype (object / category), a
+      boolean-dtype column, or a column that is entirely NaN.
+
+    Boolean-dtype columns are intentionally classified as
+    ``"categorical"``; cast to ``int`` if you want binary-treatment
+    profiling.
 
     The profile does not recommend an estimator. Consult
     ``diff_diff.get_llm_guide("autonomous")`` for the estimator-support
@@ -297,7 +305,9 @@ def _classify_treatment(
     distinct = col.dropna().unique()
     n_distinct = len(distinct)
     values_set = set(distinct.tolist())
-    is_binary_valued = n_distinct == 2 and values_set <= {0, 1, 0.0, 1.0}
+    if n_distinct == 0:
+        return ("categorical", False, {}, False, False, None, None)
+    is_binary_valued = values_set <= {0, 1, 0.0, 1.0}
 
     if not is_binary_valued:
         return ("continuous", False, {}, False, False, None, None)

tests/test_profile_panel.py

@@ -252,3 +252,67 @@ def test_alert_dataclass_is_frozen():
     a = Alert(code="x", severity="info", message="m", observed=None)
     with pytest.raises(dataclasses.FrozenInstanceError):
         a.code = "y"  # type: ignore[misc]
+
+
+def test_all_zero_treatment_is_binary_absorbing():
+    """Degenerate binary: no unit is ever treated. Must classify as binary,
+    not continuous, so the documented taxonomy matches the implementation."""
+    df = _make_panel(n_units=20, periods=range(0, 4), first_treat=None)
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    assert profile.treatment_type == "binary_absorbing"
+    assert profile.has_never_treated is True
+    assert profile.has_always_treated is False
+    assert profile.cohort_sizes == {}
+    assert profile.n_cohorts == 0
+
+
+def test_all_one_treatment_is_binary_absorbing_always_treated():
+    """Degenerate binary: every unit treated in every period. Must classify as
+    binary_absorbing with has_always_treated=True."""
+    rows = []
+    for u in range(1, 21):
+        for t in range(4):
+            rows.append({"u": u, "t": t, "tr": 1, "y": float(u) + 0.1 * t})
+    df = pd.DataFrame(rows)
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    assert profile.treatment_type == "binary_absorbing"
+    assert profile.has_never_treated is False
+    assert profile.has_always_treated is True
+    codes = _alert_codes(profile)
+    assert "has_always_treated_units" in codes
+
+
+def test_binary_with_nans_only_zeros_observed_is_binary():
+    """Binary panel with some NaNs and only 0 observed among non-NaN values —
+    still classify as binary, not continuous."""
+    rows = []
+    for u in range(1, 11):
+        for t in range(4):
+            tr = 0 if (u + t) % 2 == 0 else np.nan
+            rows.append({"u": u, "t": t, "tr": tr, "y": float(u) + 0.1 * t})
+    df = pd.DataFrame(rows)
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    assert profile.treatment_type == "binary_absorbing"
+
+
+def test_all_nan_treatment_is_categorical():
+    """Treatment column entirely NaN — classify as categorical (no info)."""
+    rows = []
+    for u in range(1, 11):
+        for t in range(4):
+            rows.append({"u": u, "t": t, "tr": np.nan, "y": float(u) + 0.1 * t})
+    df = pd.DataFrame(rows)
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    assert profile.treatment_type == "categorical"
+
+
+def test_top_level_import_surface():
+    """profile_panel, PanelProfile, and Alert must be importable from the
+    top-level namespace so `help(diff_diff)` points at real symbols."""
+    import diff_diff
+
+    assert callable(diff_diff.profile_panel)
+    assert diff_diff.PanelProfile.__name__ == "PanelProfile"
+    assert diff_diff.Alert.__name__ == "Alert"
+    for name in ("profile_panel", "PanelProfile", "Alert"):
+        assert name in diff_diff.__all__, f"{name} missing from __all__"