Codex re-review: remove float64 coercion in MPD/TWFE Conley wire-up

P1 (Methodology): the prior fix normalized `time` inside
`_compute_conley_vcov` but `MultiPeriodDiD.fit()` and
`TwoWayFixedEffects.fit()` still coerced `data[time].values.astype(np.float64)`
before passing to the helper. datetime64 / pd.Period / string time labels
fail before the helper's normalization runs, so the documented
"normalizes to dense panel-period codes" contract was unreachable on the
public estimator surfaces.

Fix: replace `.astype(np.float64)` with `np.asarray(...)` so the original
ordered labels reach the helper, which then normalizes via
`np.unique(return_inverse=True)`.

P3 (Documentation): updated the `MultiPeriodDiD` class docstring's
`vcov_type="conley"` bullet to describe the Phase 2 block-decomposed
contract (was still saying "rejected at fit-time" / "Phase 2 will add
the space-time product kernel"). Also updated the `unit` fit-arg
docstring to note it is REQUIRED when `vcov_type="conley"` rather than
"does NOT affect SE computation".

Regression: `test_multi_period_did_conley_with_datetime64_time` fits MPD
with `time_dt` (pd.to_datetime) and `time_int` (0,1,2) on the same panel
and asserts the diagonal SEs match at atol=1e-10. Verifies the end-to-end
estimator surface, not just the helper.

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

Author: igerber

diff_diff/estimators.py

@@ -1033,21 +1033,28 @@ class MultiPeriodDiD(DifferenceInDifferences):
         - ``"hc2_bm"``: one-way HC2 + Imbens-Kolesar (2016) Satterthwaite DOF
           per coefficient plus a contrast-aware DOF for the post-period-average
           ATT. **Unsupported with** ``cluster=`` — see ``cluster`` above.
-        - ``"conley"``: Conley 1999 spatial-HAC sandwich. **Accepted by the
-          constructor for sklearn-style API symmetry but rejected at
-          fit-time on ``MultiPeriodDiD``** because MultiPeriodDiD is
-          intrinsically a multi-period panel estimator and Phase 1's
-          cross-sectional Conley does not handle the time dimension. The
-          supported Phase 1 path for Conley is direct
-          ``compute_robust_vcov`` / ``LinearRegression`` on a single-period
-          regression. Phase 2 will add the space-time product kernel
-          (Driscoll-Kraay) and lift the rejection.
+        - ``"conley"``: Conley 1999 spatial-HAC sandwich via the panel
+          block-decomposed form (matches R ``conleyreg`` with
+          ``lag_cutoff > 0``). Pass ``conley_coords=(lat_col, lon_col)``,
+          ``conley_cutoff_km=<float>``, and ``conley_lag_cutoff=<int>`` on
+          the constructor; ``unit=`` must be supplied at fit-time. The
+          sandwich sums within-period spatial pairs plus within-unit
+          Bartlett serial pairs (lag=0 excluded to avoid double-counting);
+          this is NOT a multiplicative product kernel. ``conley_time`` is
+          auto-derived from the ``time`` column at fit-time and normalized
+          to dense panel-period codes ``0..T-1`` so ``conley_lag_cutoff``
+          always counts panel periods (works for int / datetime64 /
+          ``pd.Period`` / string encodings). Restrictions: ``cluster=``,
+          ``survey_design=``, and ``inference="wild_bootstrap"`` raise on
+          this path (Phase 5 / follow-up).
     alpha : float, default=0.05
         Significance level for confidence intervals.
-    conley_coords, conley_cutoff_km, conley_metric, conley_kernel
-        Accepted by the constructor for sklearn-style API symmetry, but
-        ``vcov_type="conley"`` is rejected at fit-time on ``MultiPeriodDiD``
-        (see ``vcov_type`` above).
+    conley_coords, conley_cutoff_km, conley_metric, conley_kernel, conley_lag_cutoff
+        Constructor kwargs that take effect when ``vcov_type="conley"``.
+        ``conley_coords`` is a ``(lat_col, lon_col)`` tuple of column names
+        on ``data``. ``conley_lag_cutoff`` is the within-unit Bartlett lag
+        (non-negative int; 0 means within-period spatial only, no serial
+        component).
 
     Attributes
     ----------
@@ -1147,9 +1154,10 @@ def fit(  # type: ignore[override]
         unit : str, optional
             Name of the unit identifier column. When provided, checks whether
             treatment timing varies across units and warns if staggered adoption
-            is detected (suggests CallawaySantAnna instead). Does NOT affect
-            standard error computation -- use the ``cluster`` parameter for
-            cluster-robust SEs.
+            is detected (suggests CallawaySantAnna instead). Required when
+            ``vcov_type="conley"`` (the panel block-decomposed sandwich computes
+            a per-unit serial sum). For other ``vcov_type`` values, use the
+            ``cluster`` parameter for cluster-robust SEs.
         survey_design : SurveyDesign, optional
             Survey design specification for design-based inference. When provided,
             uses Taylor Series Linearization for variance estimation and
@@ -1550,7 +1558,11 @@ def fit(  # type: ignore[override]
                     working_data[self.conley_coords[1]].values.astype(np.float64),
                 ]
             )
-            _conley_time_arr: Optional[np.ndarray] = working_data[time].values.astype(np.float64)
+            # Preserve the original time-label dtype (int, datetime64, pd.Period,
+            # string). `_compute_conley_vcov` normalizes to dense 0..T-1 codes
+            # internally; float coercion here would break datetime64 / Period /
+            # string encodings before the normalizer runs.
+            _conley_time_arr: Optional[np.ndarray] = np.asarray(working_data[time].values)
             _conley_unit_arr: Optional[np.ndarray] = working_data[unit].values
         else:
             _conley_coords_arr = None

diff_diff/twfe.py

@@ -368,7 +368,11 @@ def fit(  # type: ignore[override]
                     data[self.conley_coords[1]].values.astype(np.float64),
                 ]
             )
-            _conley_time_arr: Optional[np.ndarray] = data[time].values.astype(np.float64)
+            # Preserve the original time-label dtype (int, datetime64, pd.Period,
+            # string). `_compute_conley_vcov` normalizes to dense 0..T-1 codes
+            # internally; float coercion here would break datetime64 / Period /
+            # string encodings before the normalizer runs.
+            _conley_time_arr: Optional[np.ndarray] = np.asarray(data[time].values)
             _conley_unit_arr: Optional[np.ndarray] = data[unit].values
             # vcov_type="conley" + cluster_ids raises at the linalg validator
             # (combined kernel deferred). TWFE's auto-cluster would force that

tests/test_conley_vcov.py

@@ -1178,6 +1178,71 @@ def test_multi_period_did_conley_with_survey_design_raises(self):
                 survey_design=sd_psu,
             )
 
+    def test_multi_period_did_conley_with_datetime64_time(self):
+        """End-to-end MPD + vcov_type='conley' with datetime64 time labels.
+        Closes Codex re-review P1: the wrapper must NOT coerce time to float64
+        before passing to _compute_conley_vcov; the helper normalizes to
+        dense codes internally. Verifies the SEs match an equivalent
+        dense-integer-coded fit.
+        """
+        import pandas as pd
+
+        from diff_diff import MultiPeriodDiD
+
+        rng = np.random.default_rng(seed=37)
+        n_units = 12
+        date_labels = pd.to_datetime(["2024-01-01", "2024-04-01", "2024-08-01"])
+        rows = []
+        for u in range(n_units):
+            lat = rng.uniform(-30, 30)
+            lon = rng.uniform(-100, 100)
+            for t_idx, dt in enumerate(date_labels):
+                treated = u < 6
+                y = 0.2 * t_idx + (1.0 if (treated and t_idx >= 1) else 0.0) + rng.normal(0, 0.4)
+                rows.append(
+                    {
+                        "unit": u,
+                        "time_dt": dt,
+                        "time_int": t_idx,
+                        "y": y,
+                        "treated": int(treated),
+                        "lat": lat,
+                        "lon": lon,
+                    }
+                )
+        df_mp = pd.DataFrame(rows)
+        kwargs = dict(
+            vcov_type="conley",
+            conley_coords=("lat", "lon"),
+            conley_cutoff_km=2000.0,
+            conley_lag_cutoff=1,
+        )
+        res_int = MultiPeriodDiD(**kwargs).fit(
+            df_mp,
+            outcome="y",
+            treatment="treated",
+            time="time_int",
+            post_periods=[1, 2],
+            unit="unit",
+            reference_period=0,
+        )
+        res_dt = MultiPeriodDiD(**kwargs).fit(
+            df_mp,
+            outcome="y",
+            treatment="treated",
+            time="time_dt",
+            post_periods=[date_labels[1], date_labels[2]],
+            unit="unit",
+            reference_period=date_labels[0],
+        )
+        # Per-coefficient SE should match across the two encodings (dense
+        # codes normalize identically). MPD orders coefficients by the
+        # reference-vs-non-reference period split; with reference_period=0
+        # and post_periods=[1,2] the coefficient ordering is bit-identical.
+        se_int = np.sqrt(np.diag(res_int.vcov))
+        se_dt = np.sqrt(np.diag(res_dt.vcov))
+        np.testing.assert_allclose(se_dt, se_int, atol=1e-10)
+
     def test_multi_period_did_conley_missing_coords_raises(self):
         """MPD + vcov_type='conley' without conley_coords raises a clean
         ValueError instead of a raw TypeError on `self.conley_coords[0]`.