diff-diff 3.6.0__tar.gz → 3.6.2__tar.gz

{diff_diff-3.6.0 → diff_diff-3.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 3.6.0
+Version: 3.6.2
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
@@ -155,7 +155,7 @@ Full guide: `diff_diff.get_llm_guide("practitioner")`.
 - [TwoWayFixedEffects](https://diff-diff.readthedocs.io/en/stable/api/estimators.html) - panel data DiD with unit and time fixed effects via within-transformation or dummies
 - [MultiPeriodDiD](https://diff-diff.readthedocs.io/en/stable/api/estimators.html) - event study design with period-specific treatment effects for dynamic analysis
 - [CallawaySantAnna](https://diff-diff.readthedocs.io/en/stable/api/staggered.html) - Callaway & Sant'Anna (2021) group-time ATT estimator for staggered adoption
-- [ChaisemartinDHaultfoeuille](https://diff-diff.readthedocs.io/en/stable/api/chaisemartin_dhaultfoeuille.html) - de Chaisemartin & D'Haultfœuille (2020/2022) for **reversible (non-absorbing) treatments** with multi-horizon event study, normalized effects, cost-benefit delta, sup-t bands, and dynamic placebos. The only library option for treatments that switch on AND off. Alias `DCDH`.
+- [ChaisemartinDHaultfoeuille](https://diff-diff.readthedocs.io/en/stable/api/chaisemartin_dhaultfoeuille.html) - de Chaisemartin & D'Haultfœuille (2020/2022) for **reversible (non-absorbing) treatments** with multi-horizon event study, normalized effects, cost-benefit delta, sup-t bands, and dynamic placebos. The most general option for treatments that switch on AND off (see also `LPDiD`/`TROP` `non_absorbing`). Alias `DCDH`.
 - [SunAbraham](https://diff-diff.readthedocs.io/en/stable/api/staggered.html) - Sun & Abraham (2021) interaction-weighted estimator for heterogeneity-robust event studies
 - [ImputationDiD](https://diff-diff.readthedocs.io/en/stable/api/imputation.html) - Borusyak, Jaravel & Spiess (2024) imputation estimator, most efficient under homogeneous effects
 - [TwoStageDiD](https://diff-diff.readthedocs.io/en/stable/api/two_stage.html) - Gardner (2022) two-stage estimator with GMM sandwich variance
@@ -170,7 +170,7 @@ Full guide: `diff_diff.get_llm_guide("practitioner")`.
 - [TROP](https://diff-diff.readthedocs.io/en/stable/api/trop.html) - Triply Robust Panel estimator (Athey et al. 2025) with nuclear norm factor adjustment
 - [StaggeredTripleDifference](https://diff-diff.readthedocs.io/en/stable/api/staggered.html#staggeredtripledifference) - Ortiz-Villavicencio & Sant'Anna (2025) staggered DDD with group-time ATT
 - [WooldridgeDiD](https://diff-diff.readthedocs.io/en/stable/api/wooldridge_etwfe.html) - Wooldridge (2023, 2025) ETWFE: saturated OLS, logit/Poisson QMLE (ASF-based ATT). Alias `ETWFE`.
-- [LPDiD](https://diff-diff.readthedocs.io/en/stable/api/lpdid.html) - Dube, Girardi, Jorda & Taylor (2025) Local Projections DiD: per-horizon long-difference event study on clean controls (no negative weighting), variance- or equally-weighted ATT, for absorbing treatment
+- [LPDiD](https://diff-diff.readthedocs.io/en/stable/api/lpdid.html) - Dube, Girardi, Jorda & Taylor (2025) Local Projections DiD: per-horizon long-difference event study on clean controls (no negative weighting), variance- or equally-weighted ATT, for absorbing or non-absorbing (reversible) treatment
 - [BaconDecomposition](https://diff-diff.readthedocs.io/en/stable/api/bacon.html) - Goodman-Bacon (2021) decomposition for diagnosing TWFE bias in staggered settings
 
 ## Diagnostics & Sensitivity
@@ -198,7 +198,7 @@ No other Python or R DiD package offers design-based variance estimation for mod
 - Python 3.9 - 3.14
 - numpy >= 1.20
 - pandas >= 1.3
-- scipy >= 1.7
+- scipy >= 1.10
 
 ## Development
 

{diff_diff-3.6.0 → diff_diff-3.6.2}/README.md

@@ -102,7 +102,7 @@ Full guide: `diff_diff.get_llm_guide("practitioner")`.
 - [TwoWayFixedEffects](https://diff-diff.readthedocs.io/en/stable/api/estimators.html) - panel data DiD with unit and time fixed effects via within-transformation or dummies
 - [MultiPeriodDiD](https://diff-diff.readthedocs.io/en/stable/api/estimators.html) - event study design with period-specific treatment effects for dynamic analysis
 - [CallawaySantAnna](https://diff-diff.readthedocs.io/en/stable/api/staggered.html) - Callaway & Sant'Anna (2021) group-time ATT estimator for staggered adoption
-- [ChaisemartinDHaultfoeuille](https://diff-diff.readthedocs.io/en/stable/api/chaisemartin_dhaultfoeuille.html) - de Chaisemartin & D'Haultfœuille (2020/2022) for **reversible (non-absorbing) treatments** with multi-horizon event study, normalized effects, cost-benefit delta, sup-t bands, and dynamic placebos. The only library option for treatments that switch on AND off. Alias `DCDH`.
+- [ChaisemartinDHaultfoeuille](https://diff-diff.readthedocs.io/en/stable/api/chaisemartin_dhaultfoeuille.html) - de Chaisemartin & D'Haultfœuille (2020/2022) for **reversible (non-absorbing) treatments** with multi-horizon event study, normalized effects, cost-benefit delta, sup-t bands, and dynamic placebos. The most general option for treatments that switch on AND off (see also `LPDiD`/`TROP` `non_absorbing`). Alias `DCDH`.
 - [SunAbraham](https://diff-diff.readthedocs.io/en/stable/api/staggered.html) - Sun & Abraham (2021) interaction-weighted estimator for heterogeneity-robust event studies
 - [ImputationDiD](https://diff-diff.readthedocs.io/en/stable/api/imputation.html) - Borusyak, Jaravel & Spiess (2024) imputation estimator, most efficient under homogeneous effects
 - [TwoStageDiD](https://diff-diff.readthedocs.io/en/stable/api/two_stage.html) - Gardner (2022) two-stage estimator with GMM sandwich variance
@@ -117,7 +117,7 @@ Full guide: `diff_diff.get_llm_guide("practitioner")`.
 - [TROP](https://diff-diff.readthedocs.io/en/stable/api/trop.html) - Triply Robust Panel estimator (Athey et al. 2025) with nuclear norm factor adjustment
 - [StaggeredTripleDifference](https://diff-diff.readthedocs.io/en/stable/api/staggered.html#staggeredtripledifference) - Ortiz-Villavicencio & Sant'Anna (2025) staggered DDD with group-time ATT
 - [WooldridgeDiD](https://diff-diff.readthedocs.io/en/stable/api/wooldridge_etwfe.html) - Wooldridge (2023, 2025) ETWFE: saturated OLS, logit/Poisson QMLE (ASF-based ATT). Alias `ETWFE`.
-- [LPDiD](https://diff-diff.readthedocs.io/en/stable/api/lpdid.html) - Dube, Girardi, Jorda & Taylor (2025) Local Projections DiD: per-horizon long-difference event study on clean controls (no negative weighting), variance- or equally-weighted ATT, for absorbing treatment
+- [LPDiD](https://diff-diff.readthedocs.io/en/stable/api/lpdid.html) - Dube, Girardi, Jorda & Taylor (2025) Local Projections DiD: per-horizon long-difference event study on clean controls (no negative weighting), variance- or equally-weighted ATT, for absorbing or non-absorbing (reversible) treatment
 - [BaconDecomposition](https://diff-diff.readthedocs.io/en/stable/api/bacon.html) - Goodman-Bacon (2021) decomposition for diagnosing TWFE bias in staggered settings
 
 ## Diagnostics & Sensitivity
@@ -145,7 +145,7 @@ No other Python or R DiD package offers design-based variance estimation for mod
 - Python 3.9 - 3.14
 - numpy >= 1.20
 - pandas >= 1.3
-- scipy >= 1.7
+- scipy >= 1.10
 
 ## Development
 

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/__init__.py

@@ -301,7 +301,7 @@ ETWFE = WooldridgeDiD
 DCDH = ChaisemartinDHaultfoeuille
 HAD = HeterogeneousAdoptionDiD
 
-__version__ = "3.6.0"
+__version__ = "3.6.2"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/_backend.py

@@ -65,6 +65,14 @@ except ImportError:
     _rust_sc_weight_fw_weighted_with_convergence = None
     _rust_backend_info = None
 
+# FE-absorption MAP demeaning kernel: imported independently so a stale or
+# mixed-version extension missing only this newer symbol degrades to the
+# numpy demeaning engine WITHOUT disabling the older Rust accelerations.
+try:
+    from diff_diff._rust_backend import demean_map as _rust_demean_map
+except ImportError:
+    _rust_demean_map = None
+
 # Determine final backend based on environment variable and availability
 if _backend_env == "python":
     # Force pure Python mode - disable Rust even if available
@@ -73,6 +81,8 @@ if _backend_env == "python":
     _rust_project_simplex = None
     _rust_solve_ols = None
     _rust_compute_robust_vcov = None
+    # FE-absorption MAP demeaning kernel
+    _rust_demean_map = None
     # TROP estimator acceleration (local method)
     _rust_unit_distance_matrix = None
     _rust_loocv_grid_search = None
@@ -124,6 +134,8 @@ __all__ = [
     "_rust_project_simplex",
     "_rust_solve_ols",
     "_rust_compute_robust_vcov",
+    # FE-absorption MAP demeaning kernel
+    "_rust_demean_map",
     # TROP estimator acceleration (local method)
     "_rust_unit_distance_matrix",
     "_rust_loocv_grid_search",

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/_nprobust_port.py

@@ -1361,6 +1361,19 @@ def lprobust(
     se_cl = float(np.sqrt((deriv_fact**2) * V_Y_cl[deriv, deriv]))
     se_rb = float(np.sqrt((deriv_fact**2) * V_Y_bc[deriv, deriv]))
 
+    # Cluster-robust variance is unidentified when fewer than two clusters
+    # contribute to the ACTIVE kernel window (``eC = cluster[ind]``): the
+    # between-cluster meat is degenerate, so a finite ``se`` here would report
+    # unidentified clustered inference as if identified. NaN both SEs so any
+    # downstream inference (the ``safe_inference`` gate in
+    # ``bias_corrected_local_linear``; HAD's beta-scale rescale) is NaN-coupled.
+    # Unclustered fits (``eC is None``) are unaffected, and a clustered window
+    # with >= 2 distinct clusters is bit-identical, so the DGP-4 golden parity
+    # is preserved.
+    if eC is not None and len(np.unique(eC)) < 2:
+        se_cl = float("nan")
+        se_rb = float("nan")
+
     # --- Per-observation influence function for the BIAS-CORRECTED point
     # estimate at ``deriv`` (Phase 4.5 survey composition).
     # Aligned with ``V_Y_bc`` (NOT ``V_Y_cl``) so survey-composed variance

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/_reporting_helpers.py

@@ -635,6 +635,26 @@ def describe_target_parameter(results: Any) -> Dict[str, Any]:
             "reference": "REGISTRY.md Sec. SyntheticControl",
         }
 
+    if name == "SpilloverDiDResults":
+        return {
+            "name": "total effect on the treated (Butts spillover-aware ATT)",
+            "definition": (
+                "The total effect on the treated ``tau_total`` from Butts (2021) "
+                "ring-indicator spillover DiD, identified off FAR-AWAY control "
+                "observations (``d_it > d_bar``, Assumption 5) rather than any "
+                "not-yet-/never-treated pool. The estimator decomposes into the "
+                "DIRECT effect on treated units plus per-ring spillover-on-control "
+                "effects that relax SUTVA within the treated units' spatial "
+                "neighborhood; ``att`` is the headline total effect, while the "
+                "per-ring ``spillover_effects`` and (when ``event_study=True``) the "
+                "per-event-time direct dynamics are available on the result object "
+                "for disaggregated inference."
+            ),
+            "aggregation": "spillover",
+            "headline_attribute": "att",
+            "reference": "Butts (2021); REGISTRY.md Sec. SpilloverDiD",
+        }
+
     # Default: unrecognized result class. Fall through with a neutral
     # block — agents / downstream consumers can still dispatch on
     # ``aggregation="unknown"`` and fall back to generic ATT narration.

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/bacon.py

@@ -18,6 +18,7 @@ import numpy as np
 import pandas as pd
 
 from diff_diff.results import _format_survey_block
+from diff_diff.utils import pre_demean_norms, snap_absorbed_regressors
 from diff_diff.utils import within_transform as _within_transform_util
 
 
@@ -795,6 +796,7 @@ class BaconDecomposition:
     ) -> float:
         """Compute TWFE estimate using within-transformation."""
         # Apply two-way within transformation (weighted if survey weights provided)
+        _pre_norms = pre_demean_norms(df, [treat_col], weights=weights)
         df_dm = _within_transform_util(
             df,
             [outcome, treat_col],
@@ -803,6 +805,19 @@ class BaconDecomposition:
             suffix="_within",
             weights=weights,
         )
+        # Snap an FE-spanned treatment to exact zero: the d_var == 0 guard
+        # below then returns its deterministic 0.0 (with the cause warning)
+        # instead of an arbitrary junk/junk division.
+        snap_absorbed_regressors(
+            df_dm,
+            [treat_col],
+            _pre_norms,
+            absorbed_desc=f"unit '{unit}' and time '{time}' fixed effects",
+            group_vars=[unit, time],
+            suffix="_within",
+            display_names={treat_col: "treatment"},
+            weights=weights,
+        )
 
         # Extract within-transformed values
         y_within = df_dm[f"{outcome}_within"].values

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/business_report.py

@@ -353,12 +353,21 @@ class BusinessReport:
         """Return a structured multi-section markdown report."""
         base = _render_full_report(self.to_dict())
         if self._include_appendix:
+            appendix_text = None
             try:
                 appendix = self._results.summary()
-            except Exception:  # noqa: BLE001
-                appendix = None
-            if appendix:
-                base = base + "\n\n## Technical Appendix\n\n```\n" + str(appendix) + "\n```\n"
+                if appendix:
+                    appendix_text = str(appendix)
+            except Exception as exc:  # noqa: BLE001
+                appendix_error = type(exc).__name__ or "Exception"
+                base = (
+                    base
+                    + "\n\n## Technical Appendix\n\n"
+                    + "Technical appendix unavailable: estimator summary rendering failed "
+                    + f"({appendix_error}).\n"
+                )
+            if appendix_text:
+                base = base + "\n\n## Technical Appendix\n\n```\n" + appendix_text + "\n```\n"
         return base
 
     def export_markdown(self) -> str:

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/chaisemartin_dhaultfoeuille.py

@@ -1,9 +1,14 @@
 """
 de Chaisemartin-D'Haultfoeuille (dCDH) estimator for reversible-treatment DiD.
 
-The dCDH estimator is the only modern DiD estimator in the diff-diff library
-that handles **non-absorbing (reversible) treatments** — treatment can switch
-on AND off over time. All other staggered estimators in the library
+The dCDH estimator is the most general DiD estimator in the diff-diff library
+for **non-absorbing (reversible) treatments** — treatment can switch on AND off
+over time, switcher vs non-switcher comparisons are its primitive object, and it
+allows dynamic (carryover) effects with explicit joiner/leaver (``DID_+`` /
+``DID_-``) decomposition. ``LPDiD`` (``non_absorbing="first_entry"`` /
+``"effect_stabilization"``) and ``TROP`` (``non_absorbing=True``, under a
+no-dynamic-effects assumption) also accept non-absorbing treatment under stronger
+assumptions. The remaining staggered estimators in the library
 (``CallawaySantAnna``, ``SunAbraham``, ``ImputationDiD``, ``TwoStageDiD``,
 ``EfficientDiD``, ``WooldridgeDiD``) assume treatment is absorbing.
 
@@ -354,9 +359,11 @@ class ChaisemartinDHaultfoeuille(ChaisemartinDHaultfoeuilleBootstrapMixin):
     """
     de Chaisemartin-D'Haultfoeuille (dCDH) estimator.
 
-    The only modern DiD estimator in the library that handles **reversible
-    (non-absorbing) treatments** - treatment may switch on AND off over
-    time. Computes the contemporaneous-switch DiD ``DID_M`` from the
+    The most general library estimator for **reversible (non-absorbing)
+    treatments** - treatment may switch on AND off over time, with explicit
+    joiner/leaver (``DID_+`` / ``DID_-``) decomposition (``LPDiD`` and ``TROP``
+    also support non-absorbing treatment under stronger assumptions; see their
+    ``non_absorbing`` parameters). Computes the contemporaneous-switch DiD ``DID_M`` from the
     AER 2020 paper (equivalently ``DID_1`` at horizon ``l = 1`` of the
     dynamic companion paper, NBER WP 29873) plus the full multi-horizon
     event study ``DID_l`` for ``l = 1..L_max`` via the ``L_max`` parameter

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/chaisemartin_dhaultfoeuille_results.py

@@ -4,9 +4,11 @@ Result containers for the de Chaisemartin-D'Haultfoeuille (dCDH) estimator.
 This module contains ``ChaisemartinDHaultfoeuilleResults`` and
 ``DCDHBootstrapResults`` dataclasses produced by the
 ``ChaisemartinDHaultfoeuille`` (alias ``DCDH``) estimator. The dCDH
-estimator is the only modern DiD estimator in the library that handles
-non-absorbing (reversible) treatments. Phase 1 ships the contemporaneous-
-switch case ``DID_M`` (= ``DID_1`` of the dynamic companion paper).
+estimator is the most general library estimator for non-absorbing
+(reversible) treatments (``LPDiD`` and ``TROP`` also support non-absorbing
+treatment under stronger assumptions; see their ``non_absorbing`` parameters).
+Phase 1 ships the contemporaneous-switch case ``DID_M`` (= ``DID_1`` of the
+dynamic companion paper).
 
 References
 ----------

{diff_diff-3.6.0 → diff_diff-3.6.2}/diff_diff/continuous_did.py

@@ -31,9 +31,9 @@ from diff_diff.continuous_did_results import (
 )
 from diff_diff.linalg import _rank_guarded_inv, solve_ols
 from diff_diff.survey import (
-    ResolvedSurveyDesign,
     _resolve_survey_for_fit,
     _validate_unit_constant_survey,
+    build_unit_first_row_index,
     compute_survey_vcov,
 )
 from diff_diff.utils import safe_inference
@@ -413,8 +413,7 @@ class ContinuousDiD:
 
         # Filter out NaN cells (e.g., from zero effective survey mass)
         gt_results = {
-            gt: r for gt, r in gt_results.items()
-            if np.isfinite(r.get("att_glob", np.nan))
+            gt: r for gt, r in gt_results.items() if np.isfinite(r.get("att_glob", np.nan))
         }
 
         if len(gt_results) == 0:
@@ -573,9 +572,12 @@ class ContinuousDiD:
                 # Survey df for t-distribution inference (unit-level, not panel-level)
                 _survey_df = analytic.get("df_survey")
                 # Guard: replicate design with undefined df → NaN inference
-                if (_survey_df is None and resolved_survey is not None
-                        and hasattr(resolved_survey, 'uses_replicate_variance')
-                        and resolved_survey.uses_replicate_variance):
+                if (
+                    _survey_df is None
+                    and resolved_survey is not None
+                    and hasattr(resolved_survey, "uses_replicate_variance")
+                    and resolved_survey.uses_replicate_variance
+                ):
                     _survey_df = 0
 
                 # Recompute survey_metadata from unit-level design so reported
@@ -589,8 +591,7 @@ class ContinuousDiD:
 
                 # Propagate replicate df override to survey_metadata for display
                 # (but not the df=0 sentinel — keep metadata as None for undefined df)
-                if (_survey_df is not None and _survey_df != 0
-                        and survey_metadata is not None):
+                if _survey_df is not None and _survey_df != 0 and survey_metadata is not None:
                     if survey_metadata.df_survey != _survey_df:
                         survey_metadata.df_survey = _survey_df
 
@@ -624,30 +625,8 @@ class ContinuousDiD:
                     unit_resolved_es = None
                     if resolved_survey is not None:
                         row_idx = precomp["unit_first_panel_row"]
-                        uw = (
-                            precomp.get("unit_survey_weights")
-                            if precomp.get("unit_survey_weights") is not None
-                            else np.ones(n_units)
-                        )
-                        us = (
-                            resolved_survey.strata[row_idx]
-                            if resolved_survey.strata is not None
-                            else None
-                        )
-                        up = (
-                            resolved_survey.psu[row_idx]
-                            if resolved_survey.psu is not None
-                            else None
-                        )
-                        uf = (
-                            resolved_survey.fpc[row_idx]
-                            if resolved_survey.fpc is not None
-                            else None
-                        )
-                        n_strata_u = len(np.unique(us)) if us is not None else 0
-                        n_psu_u = len(np.unique(up)) if up is not None else 0
-                        unit_resolved_es = resolved_survey.subset_to_units(
-                            row_idx, uw, us, up, uf, n_strata_u, n_psu_u,
+                        unit_resolved_es = resolved_survey.subset_to_units_by_row_idx(
+                            row_idx, unit_weights=precomp.get("unit_survey_weights")
                         )
 
                     for e_val, info_e in event_study_effects.items():
@@ -711,13 +690,21 @@ class ContinuousDiD:
 
                                 # Score-scale: psi = w * if_es (matches TSL bread)
                                 psi_es = unit_resolved_es.weights * if_es
-                                variance, _nv = compute_replicate_if_variance(psi_es, unit_resolved_es)
-                                es_se = float(np.sqrt(max(variance, 0.0))) if np.isfinite(variance) else np.nan
+                                variance, _nv = compute_replicate_if_variance(
+                                    psi_es, unit_resolved_es
+                                )
+                                es_se = (
+                                    float(np.sqrt(max(variance, 0.0)))
+                                    if np.isfinite(variance)
+                                    else np.nan
+                                )
                             else:
                                 X_ones_es = np.ones((n_units, 1))
                                 tsl_scale_es = float(unit_resolved_es.weights.sum())
                                 if_es_tsl = if_es * tsl_scale_es
-                                vcov_es = compute_survey_vcov(X_ones_es, if_es_tsl, unit_resolved_es)
+                                vcov_es = compute_survey_vcov(
+                                    X_ones_es, if_es_tsl, unit_resolved_es
+                                )
                                 es_se = float(np.sqrt(np.abs(vcov_es[0, 0])))
                         else:
                             es_se = float(np.sqrt(np.sum(if_es**2)))
@@ -831,15 +818,11 @@ class ContinuousDiD:
             unit_cohorts[i] = unit_first.loc[u, first_treat]
             dose_vector[i] = unit_first.loc[u, dose]
 
-        # Build unit-to-first-panel-row mapping (for subsetting panel-level arrays)
-        # This maps each unit index to the positional index of its first row in df.
-        unit_first_panel_row = np.zeros(n_units, dtype=int)
-        seen_units: set = set()
-        for pos_idx, (_, row) in enumerate(df.iterrows()):
-            u = row[unit]
-            if u not in seen_units:
-                seen_units.add(u)
-                unit_first_panel_row[unit_to_idx[u]] = pos_idx
+        # Build unit-to-first-panel-row mapping (for subsetting panel-level
+        # arrays): the positional index of each unit's first row in df, aligned
+        # to ``all_units`` (== ``unit_to_idx`` order since
+        # ``unit_to_idx = {u: i for i, u in enumerate(all_units)}``).
+        unit_first_panel_row = build_unit_first_row_index(df[unit].values, all_units)
 
         # Per-unit survey weights (take first obs per unit from panel data)
         unit_survey_weights = None
@@ -949,8 +932,10 @@ class ContinuousDiD:
             # Guard against zero effective mass (e.g., after subpopulation)
             if np.sum(w_treated) <= 0 or np.sum(w_control) <= 0:
                 return {
-                    "att_glob": np.nan, "acrt_glob": np.nan,
-                    "n_treated": 0, "n_control": 0,
+                    "att_glob": np.nan,
+                    "acrt_glob": np.nan,
+                    "n_treated": 0,
+                    "n_control": 0,
                     "att_d": np.full(len(dvals), np.nan),
                     "acrt_d": np.full(len(dvals), np.nan),
                 }
@@ -1293,23 +1278,8 @@ class ContinuousDiD:
             # but influence functions are unit-level (n_units). Build a unit-level
             # ResolvedSurveyDesign by subsetting to one obs per unit.
             row_idx = precomp["unit_first_panel_row"]
-            unit_weights = precomp.get("unit_survey_weights")
-            if unit_weights is None:
-                unit_weights = np.ones(n_units)
-
-            unit_strata = (
-                resolved_survey.strata[row_idx] if resolved_survey.strata is not None else None
-            )
-            unit_psu = resolved_survey.psu[row_idx] if resolved_survey.psu is not None else None
-            unit_fpc = resolved_survey.fpc[row_idx] if resolved_survey.fpc is not None else None
-
-            # Count unique strata/PSU in the unit-level subset
-            n_strata_unit = len(np.unique(unit_strata)) if unit_strata is not None else 0
-            n_psu_unit = len(np.unique(unit_psu)) if unit_psu is not None else 0
-
-            unit_resolved = resolved_survey.subset_to_units(
-                row_idx, unit_weights, unit_strata, unit_psu, unit_fpc,
-                n_strata_unit, n_psu_unit,
+            unit_resolved = resolved_survey.subset_to_units_by_row_idx(
+                row_idx, unit_weights=precomp.get("unit_survey_weights")
             )
 
             X_ones = np.ones((n_units, 1))
@@ -1370,7 +1340,11 @@ class ContinuousDiD:
 
         # Return unit-level survey df and resolved design for metadata recomputation
         # Only override with n_valid-based df when replicates were actually dropped
-        if resolved_survey is not None and hasattr(resolved_survey, 'uses_replicate_variance') and resolved_survey.uses_replicate_variance:
+        if (
+            resolved_survey is not None
+            and hasattr(resolved_survey, "uses_replicate_variance")
+            and resolved_survey.uses_replicate_variance
+        ):
             if _rep_n_valid < unit_resolved.n_replicates:
                 unit_df_survey = _rep_n_valid - 1 if _rep_n_valid > 1 else None
             else:
@@ -1415,7 +1389,11 @@ class ContinuousDiD:
 
         # Reject replicate-weight designs for bootstrap — replicate variance
         # is an analytical alternative to bootstrap, not compatible with it
-        if resolved_survey is not None and hasattr(resolved_survey, "uses_replicate_variance") and resolved_survey.uses_replicate_variance:
+        if (
+            resolved_survey is not None
+            and hasattr(resolved_survey, "uses_replicate_variance")
+            and resolved_survey.uses_replicate_variance
+        ):
             raise NotImplementedError(
                 "ContinuousDiD bootstrap (n_bootstrap > 0) is not supported "
                 "with replicate-weight survey designs. Replicate weights provide "
@@ -1429,22 +1407,9 @@ class ContinuousDiD:
         # Build unit-level ResolvedSurveyDesign for survey-aware bootstrap
         unit_resolved = None
         if resolved_survey is not None:
-            from diff_diff.survey import ResolvedSurveyDesign
-
             row_idx = precomp["unit_first_panel_row"]
-            unit_weights = precomp.get("unit_survey_weights")
-            if unit_weights is None:
-                unit_weights = np.ones(n_units)
-            unit_strata = (
-                resolved_survey.strata[row_idx] if resolved_survey.strata is not None else None
-            )
-            unit_psu = resolved_survey.psu[row_idx] if resolved_survey.psu is not None else None
-            unit_fpc = resolved_survey.fpc[row_idx] if resolved_survey.fpc is not None else None
-            n_strata_u = len(np.unique(unit_strata)) if unit_strata is not None else 0
-            n_psu_u = len(np.unique(unit_psu)) if unit_psu is not None else 0
-            unit_resolved = resolved_survey.subset_to_units(
-                row_idx, unit_weights, unit_strata, unit_psu, unit_fpc,
-                n_strata_u, n_psu_u,
+            unit_resolved = resolved_survey.subset_to_units_by_row_idx(
+                row_idx, unit_weights=precomp.get("unit_survey_weights")
             )
 
         # Generate bootstrap weights — PSU-level when survey design is present
@@ -1682,7 +1647,7 @@ class ContinuousDiD:
                     boot_es[e],
                     alpha=self.alpha,
                     context=f"event study e={e}",
-                    )
+                )
                 es_se[e] = se_e
                 es_ci[e] = ci_e
                 es_p[e] = p_e