diff-diff 2.3.1__tar.gz → 2.4.0__tar.gz

diff_diff-2.3.1/README.md → diff_diff-2.4.0/PKG-INFO

@@ -1,3 +1,41 @@
+Metadata-Version: 2.4
+Name: diff-diff
+Version: 2.4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-xdist>=3.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
+Requires-Dist: black>=23.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.1.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0 ; extra == 'dev'
+Requires-Dist: maturin>=1.4,<2.0 ; extra == 'dev'
+Requires-Dist: sphinx>=6.0 ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=1.0 ; extra == 'docs'
+Provides-Extra: dev
+Provides-Extra: docs
+Summary: A library for Difference-in-Differences causal inference analysis
+Keywords: causal-inference,difference-in-differences,econometrics,statistics,treatment-effects
+Author: diff-diff contributors
+License-Expression: MIT
+Requires-Python: >=3.9, <3.14
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://diff-diff.readthedocs.io
+Project-URL: Homepage, https://github.com/igerber/diff-diff
+Project-URL: Issues, https://github.com/igerber/diff-diff/issues
+Project-URL: Repository, https://github.com/igerber/diff-diff
+
 # diff-diff
 
 A Python library for Difference-in-Differences (DiD) causal inference analysis with an sklearn-like API and statsmodels-style outputs.
@@ -70,7 +108,7 @@ Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1
 - **Wild cluster bootstrap**: Valid inference with few clusters (<50) using Rademacher, Webb, or Mammen weights
 - **Panel data support**: Two-way fixed effects estimator for panel designs
 - **Multi-period analysis**: Event-study style DiD with period-specific treatment effects
-- **Staggered adoption**: Callaway-Sant'Anna (2021), Sun-Abraham (2021), and Borusyak-Jaravel-Spiess (2024) imputation estimators for heterogeneous treatment timing
+- **Staggered adoption**: Callaway-Sant'Anna (2021), Sun-Abraham (2021), Borusyak-Jaravel-Spiess (2024) imputation, and Two-Stage DiD (Gardner 2022) estimators for heterogeneous treatment timing
 - **Triple Difference (DDD)**: Ortiz-Villavicencio & Sant'Anna (2025) estimators with proper covariate handling
 - **Synthetic DiD**: Combined DiD with synthetic control for improved robustness
 - **Triply Robust Panel (TROP)**: Factor-adjusted DiD with synthetic weights (Athey et al. 2025)
@@ -927,6 +965,53 @@ ImputationDiD(
 | Inference | Conservative variance (Theorem 3) | Multiplier bootstrap |
 | Pre-trends | Built-in F-test (Equation 9) | Separate testing |
 
+### Two-Stage DiD (Gardner 2022)
+
+Two-Stage DiD addresses TWFE bias in staggered adoption designs by estimating unit and time fixed effects on untreated observations only, then regressing the residualized outcomes on treatment indicators. Point estimates match the Imputation DiD estimator (Borusyak et al. 2024); the key difference is that Two-Stage DiD uses a GMM sandwich variance estimator that accounts for first-stage estimation error, while Imputation DiD uses a conservative variance (Theorem 3).
+
+```python
+from diff_diff import TwoStageDiD
+
+# Basic usage
+est = TwoStageDiD()
+results = est.fit(data, outcome='outcome', unit='unit', time='period', first_treat='first_treat')
+results.print_summary()
+```
+
+**Event study:**
+
+```python
+# Event study aggregation with visualization
+results = est.fit(data, outcome='outcome', unit='unit', time='period',
+                  first_treat='first_treat', aggregate='event_study')
+plot_event_study(results)
+```
+
+**Parameters:**
+
+```python
+TwoStageDiD(
+    anticipation=0,                   # Periods of anticipation effects
+    alpha=0.05,                       # Significance level for CIs
+    cluster=None,                     # Column for cluster-robust SEs (defaults to unit)
+    n_bootstrap=0,                    # Bootstrap iterations (0 = analytical GMM SEs)
+    seed=None,                        # Random seed
+    rank_deficient_action='warn',     # 'warn', 'error', or 'silent'
+    horizon_max=None,                 # Max event-study horizon
+)
+```
+
+**When to use Two-Stage DiD vs Imputation DiD:**
+
+| Aspect | Two-Stage DiD | Imputation DiD |
+|--------|--------------|---------------|
+| Point estimates | Identical | Identical |
+| Variance | GMM sandwich (accounts for first-stage error) | Conservative (Theorem 3, may overcover) |
+| Intuition | Residualize then regress | Impute counterfactuals then aggregate |
+| Reference impl. | R `did2s` package | R `didimputation` package |
+
+Both estimators are the efficient estimator under homogeneous treatment effects, producing shorter confidence intervals than Callaway-Sant'Anna or Sun-Abraham.
+
 ### Triple Difference (DDD)
 
 Triple Difference (DDD) is used when treatment requires satisfying two criteria: belonging to a treated **group** AND being in an eligible **partition**. The `TripleDifference` class implements the methodology from Ortiz-Villavicencio & Sant'Anna (2025), which correctly handles covariate adjustment (unlike naive implementations).
@@ -2104,6 +2189,58 @@ ImputationDiD(
 | `to_dataframe(level)` | Convert to DataFrame ('observation', 'event_study', 'group') |
 | `pretrend_test(n_leads)` | Run pre-trend F-test (Equation 9) |
 
+### TwoStageDiD
+
+```python
+TwoStageDiD(
+    anticipation=0,                   # Periods of anticipation effects
+    alpha=0.05,                       # Significance level for CIs
+    cluster=None,                     # Column for cluster-robust SEs (defaults to unit)
+    n_bootstrap=0,                    # Bootstrap iterations (0 = analytical GMM SEs)
+    seed=None,                        # Random seed
+    rank_deficient_action='warn',     # 'warn', 'error', or 'silent'
+    horizon_max=None,                 # Max event-study horizon
+)
+```
+
+**fit() Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `data` | DataFrame | Panel data |
+| `outcome` | str | Outcome variable column name |
+| `unit` | str | Unit identifier column |
+| `time` | str | Time period column |
+| `first_treat` | str | First treatment period column (0 for never-treated) |
+| `covariates` | list | Covariate column names |
+| `aggregate` | str | Aggregation: None, "event_study", "group", "all" |
+| `balance_e` | int | Balance event study to this many pre-treatment periods |
+
+### TwoStageDiDResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `overall_att` | Overall average treatment effect on the treated |
+| `overall_se` | Standard error (GMM sandwich variance) |
+| `overall_t_stat` | T-statistic |
+| `overall_p_value` | P-value for H0: ATT = 0 |
+| `overall_conf_int` | Confidence interval |
+| `event_study_effects` | Dict of relative time -> effect dict (if `aggregate='event_study'` or `'all'`) |
+| `group_effects` | Dict of cohort -> effect dict (if `aggregate='group'` or `'all'`) |
+| `treatment_effects` | DataFrame of unit-level treatment effects |
+| `n_treated_obs` | Number of treated observations |
+| `n_untreated_obs` | Number of untreated observations |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `summary(alpha)` | Get formatted summary string |
+| `print_summary(alpha)` | Print summary to stdout |
+| `to_dataframe(level)` | Convert to DataFrame ('observation', 'event_study', 'group') |
+
 ### TripleDifference
 
 ```python
@@ -2452,7 +2589,7 @@ Returns DataFrame with columns: `unit`, `quality_score`, `outcome_trend_score`,
 
 ## Requirements
 
-- Python >= 3.9
+- Python 3.9 - 3.13
 - numpy >= 1.20
 - pandas >= 1.3
 - scipy >= 1.7
@@ -2582,6 +2719,10 @@ The `HonestDiD` module implements sensitivity analysis methods for relaxing the
 
 - **Sun, L., & Abraham, S. (2021).** "Estimating Dynamic Treatment Effects in Event Studies with Heterogeneous Treatment Effects." *Journal of Econometrics*, 225(2), 175-199. [https://doi.org/10.1016/j.jeconom.2020.09.006](https://doi.org/10.1016/j.jeconom.2020.09.006)
 
+- **Gardner, J. (2022).** "Two-stage differences in differences." *arXiv preprint arXiv:2207.05943*. [https://arxiv.org/abs/2207.05943](https://arxiv.org/abs/2207.05943)
+
+- **Butts, K., & Gardner, J. (2022).** "did2s: Two-Stage Difference-in-Differences." *The R Journal*, 14(1), 162-173. [https://doi.org/10.32614/RJ-2022-048](https://doi.org/10.32614/RJ-2022-048)
+
 - **de Chaisemartin, C., & D'Haultfœuille, X. (2020).** "Two-Way Fixed Effects Estimators with Heterogeneous Treatment Effects." *American Economic Review*, 110(9), 2964-2996. [https://doi.org/10.1257/aer.20181169](https://doi.org/10.1257/aer.20181169)
 
 - **Goodman-Bacon, A. (2021).** "Difference-in-Differences with Variation in Treatment Timing." *Journal of Econometrics*, 225(2), 254-277. [https://doi.org/10.1016/j.jeconom.2021.03.014](https://doi.org/10.1016/j.jeconom.2021.03.014)
@@ -2605,3 +2746,4 @@ The `HonestDiD` module implements sensitivity analysis methods for relaxing the
 ## License
 
 MIT License
+

diff_diff-2.3.1/PKG-INFO → diff_diff-2.4.0/README.md

@@ -1,40 +1,3 @@
-Metadata-Version: 2.4
-Name: diff-diff
-Version: 2.3.1
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Science/Research
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Dist: numpy>=1.20.0
-Requires-Dist: pandas>=1.3.0
-Requires-Dist: scipy>=1.7.0
-Requires-Dist: pytest>=7.0 ; extra == 'dev'
-Requires-Dist: pytest-xdist>=3.0 ; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
-Requires-Dist: black>=23.0 ; extra == 'dev'
-Requires-Dist: ruff>=0.1.0 ; extra == 'dev'
-Requires-Dist: mypy>=1.0 ; extra == 'dev'
-Requires-Dist: maturin>=1.4,<2.0 ; extra == 'dev'
-Requires-Dist: sphinx>=6.0 ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme>=1.0 ; extra == 'docs'
-Provides-Extra: dev
-Provides-Extra: docs
-Summary: A library for Difference-in-Differences causal inference analysis
-Keywords: causal-inference,difference-in-differences,econometrics,statistics,treatment-effects
-Author: diff-diff contributors
-License-Expression: MIT
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Documentation, https://diff-diff.readthedocs.io
-Project-URL: Homepage, https://github.com/igerber/diff-diff
-Project-URL: Issues, https://github.com/igerber/diff-diff/issues
-Project-URL: Repository, https://github.com/igerber/diff-diff
-
 # diff-diff
 
 A Python library for Difference-in-Differences (DiD) causal inference analysis with an sklearn-like API and statsmodels-style outputs.
@@ -107,7 +70,7 @@ Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1
 - **Wild cluster bootstrap**: Valid inference with few clusters (<50) using Rademacher, Webb, or Mammen weights
 - **Panel data support**: Two-way fixed effects estimator for panel designs
 - **Multi-period analysis**: Event-study style DiD with period-specific treatment effects
-- **Staggered adoption**: Callaway-Sant'Anna (2021), Sun-Abraham (2021), and Borusyak-Jaravel-Spiess (2024) imputation estimators for heterogeneous treatment timing
+- **Staggered adoption**: Callaway-Sant'Anna (2021), Sun-Abraham (2021), Borusyak-Jaravel-Spiess (2024) imputation, and Two-Stage DiD (Gardner 2022) estimators for heterogeneous treatment timing
 - **Triple Difference (DDD)**: Ortiz-Villavicencio & Sant'Anna (2025) estimators with proper covariate handling
 - **Synthetic DiD**: Combined DiD with synthetic control for improved robustness
 - **Triply Robust Panel (TROP)**: Factor-adjusted DiD with synthetic weights (Athey et al. 2025)
@@ -964,6 +927,53 @@ ImputationDiD(
 | Inference | Conservative variance (Theorem 3) | Multiplier bootstrap |
 | Pre-trends | Built-in F-test (Equation 9) | Separate testing |
 
+### Two-Stage DiD (Gardner 2022)
+
+Two-Stage DiD addresses TWFE bias in staggered adoption designs by estimating unit and time fixed effects on untreated observations only, then regressing the residualized outcomes on treatment indicators. Point estimates match the Imputation DiD estimator (Borusyak et al. 2024); the key difference is that Two-Stage DiD uses a GMM sandwich variance estimator that accounts for first-stage estimation error, while Imputation DiD uses a conservative variance (Theorem 3).
+
+```python
+from diff_diff import TwoStageDiD
+
+# Basic usage
+est = TwoStageDiD()
+results = est.fit(data, outcome='outcome', unit='unit', time='period', first_treat='first_treat')
+results.print_summary()
+```
+
+**Event study:**
+
+```python
+# Event study aggregation with visualization
+results = est.fit(data, outcome='outcome', unit='unit', time='period',
+                  first_treat='first_treat', aggregate='event_study')
+plot_event_study(results)
+```
+
+**Parameters:**
+
+```python
+TwoStageDiD(
+    anticipation=0,                   # Periods of anticipation effects
+    alpha=0.05,                       # Significance level for CIs
+    cluster=None,                     # Column for cluster-robust SEs (defaults to unit)
+    n_bootstrap=0,                    # Bootstrap iterations (0 = analytical GMM SEs)
+    seed=None,                        # Random seed
+    rank_deficient_action='warn',     # 'warn', 'error', or 'silent'
+    horizon_max=None,                 # Max event-study horizon
+)
+```
+
+**When to use Two-Stage DiD vs Imputation DiD:**
+
+| Aspect | Two-Stage DiD | Imputation DiD |
+|--------|--------------|---------------|
+| Point estimates | Identical | Identical |
+| Variance | GMM sandwich (accounts for first-stage error) | Conservative (Theorem 3, may overcover) |
+| Intuition | Residualize then regress | Impute counterfactuals then aggregate |
+| Reference impl. | R `did2s` package | R `didimputation` package |
+
+Both estimators are the efficient estimator under homogeneous treatment effects, producing shorter confidence intervals than Callaway-Sant'Anna or Sun-Abraham.
+
 ### Triple Difference (DDD)
 
 Triple Difference (DDD) is used when treatment requires satisfying two criteria: belonging to a treated **group** AND being in an eligible **partition**. The `TripleDifference` class implements the methodology from Ortiz-Villavicencio & Sant'Anna (2025), which correctly handles covariate adjustment (unlike naive implementations).
@@ -2141,6 +2151,58 @@ ImputationDiD(
 | `to_dataframe(level)` | Convert to DataFrame ('observation', 'event_study', 'group') |
 | `pretrend_test(n_leads)` | Run pre-trend F-test (Equation 9) |
 
+### TwoStageDiD
+
+```python
+TwoStageDiD(
+    anticipation=0,                   # Periods of anticipation effects
+    alpha=0.05,                       # Significance level for CIs
+    cluster=None,                     # Column for cluster-robust SEs (defaults to unit)
+    n_bootstrap=0,                    # Bootstrap iterations (0 = analytical GMM SEs)
+    seed=None,                        # Random seed
+    rank_deficient_action='warn',     # 'warn', 'error', or 'silent'
+    horizon_max=None,                 # Max event-study horizon
+)
+```
+
+**fit() Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `data` | DataFrame | Panel data |
+| `outcome` | str | Outcome variable column name |
+| `unit` | str | Unit identifier column |
+| `time` | str | Time period column |
+| `first_treat` | str | First treatment period column (0 for never-treated) |
+| `covariates` | list | Covariate column names |
+| `aggregate` | str | Aggregation: None, "event_study", "group", "all" |
+| `balance_e` | int | Balance event study to this many pre-treatment periods |
+
+### TwoStageDiDResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `overall_att` | Overall average treatment effect on the treated |
+| `overall_se` | Standard error (GMM sandwich variance) |
+| `overall_t_stat` | T-statistic |
+| `overall_p_value` | P-value for H0: ATT = 0 |
+| `overall_conf_int` | Confidence interval |
+| `event_study_effects` | Dict of relative time -> effect dict (if `aggregate='event_study'` or `'all'`) |
+| `group_effects` | Dict of cohort -> effect dict (if `aggregate='group'` or `'all'`) |
+| `treatment_effects` | DataFrame of unit-level treatment effects |
+| `n_treated_obs` | Number of treated observations |
+| `n_untreated_obs` | Number of untreated observations |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `summary(alpha)` | Get formatted summary string |
+| `print_summary(alpha)` | Print summary to stdout |
+| `to_dataframe(level)` | Convert to DataFrame ('observation', 'event_study', 'group') |
+
 ### TripleDifference
 
 ```python
@@ -2489,7 +2551,7 @@ Returns DataFrame with columns: `unit`, `quality_score`, `outcome_trend_score`,
 
 ## Requirements
 
-- Python >= 3.9
+- Python 3.9 - 3.13
 - numpy >= 1.20
 - pandas >= 1.3
 - scipy >= 1.7
@@ -2619,6 +2681,10 @@ The `HonestDiD` module implements sensitivity analysis methods for relaxing the
 
 - **Sun, L., & Abraham, S. (2021).** "Estimating Dynamic Treatment Effects in Event Studies with Heterogeneous Treatment Effects." *Journal of Econometrics*, 225(2), 175-199. [https://doi.org/10.1016/j.jeconom.2020.09.006](https://doi.org/10.1016/j.jeconom.2020.09.006)
 
+- **Gardner, J. (2022).** "Two-stage differences in differences." *arXiv preprint arXiv:2207.05943*. [https://arxiv.org/abs/2207.05943](https://arxiv.org/abs/2207.05943)
+
+- **Butts, K., & Gardner, J. (2022).** "did2s: Two-Stage Difference-in-Differences." *The R Journal*, 14(1), 162-173. [https://doi.org/10.32614/RJ-2022-048](https://doi.org/10.32614/RJ-2022-048)
+
 - **de Chaisemartin, C., & D'Haultfœuille, X. (2020).** "Two-Way Fixed Effects Estimators with Heterogeneous Treatment Effects." *American Economic Review*, 110(9), 2964-2996. [https://doi.org/10.1257/aer.20181169](https://doi.org/10.1257/aer.20181169)
 
 - **Goodman-Bacon, A. (2021).** "Difference-in-Differences with Variation in Treatment Timing." *Journal of Econometrics*, 225(2), 254-277. [https://doi.org/10.1016/j.jeconom.2021.03.014](https://doi.org/10.1016/j.jeconom.2021.03.014)
@@ -2642,4 +2708,3 @@ The `HonestDiD` module implements sensitivity analysis methods for relaxing the
 ## License
 
 MIT License
-

{diff_diff-2.3.1 → diff_diff-2.4.0}/diff_diff/__init__.py

@@ -101,6 +101,12 @@ from diff_diff.imputation import (
     ImputationDiDResults,
     imputation_did,
 )
+from diff_diff.two_stage import (
+    TwoStageBootstrapResults,
+    TwoStageDiD,
+    TwoStageDiDResults,
+    two_stage_did,
+)
 from diff_diff.sun_abraham import (
     SABootstrapResults,
     SunAbraham,
@@ -142,7 +148,7 @@ from diff_diff.datasets import (
     load_mpdta,
 )
 
-__version__ = "2.3.1"
+__version__ = "2.4.0"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",
@@ -152,6 +158,7 @@ __all__ = [
     "CallawaySantAnna",
     "SunAbraham",
     "ImputationDiD",
+    "TwoStageDiD",
     "TripleDifference",
     "TROP",
     # Bacon Decomposition
@@ -173,6 +180,9 @@ __all__ = [
     "ImputationDiDResults",
     "ImputationBootstrapResults",
     "imputation_did",
+    "TwoStageDiDResults",
+    "TwoStageBootstrapResults",
+    "two_stage_did",
     "TripleDifferenceResults",
     "triple_difference",
     "TROPResults",

{diff_diff-2.3.1 → diff_diff-2.4.0}/diff_diff/staggered.py

@@ -415,6 +415,7 @@ class CallawaySantAnna(
             cohort_masks[g] = (unit_cohorts == g)
 
         # Never-treated mask
+        # np.inf was normalized to 0 in fit(), so the np.inf check is defensive only
         never_treated_mask = (unit_cohorts == 0) | (unit_cohorts == np.inf)
 
         # Pre-compute covariate matrices by time period if needed
@@ -639,13 +640,15 @@ class CallawaySantAnna(
         # This avoids hardcoding column names in internal methods
         df['first_treat'] = df[first_treat]
 
+        # Never-treated indicator (must precede treatment_groups to exclude np.inf)
+        df['_never_treated'] = (df[first_treat] == 0) | (df[first_treat] == np.inf)
+        # Normalize np.inf → 0 so all downstream `> 0` checks exclude never-treated
+        df.loc[df[first_treat] == np.inf, first_treat] = 0
+
         # Identify groups and time periods
         time_periods = sorted(df[time].unique())
         treatment_groups = sorted([g for g in df[first_treat].unique() if g > 0])
 
-        # Never-treated indicator (first_treat = 0 or inf)
-        df['_never_treated'] = (df[first_treat] == 0) | (df[first_treat] == np.inf)
-
         # Get unique units
         unit_info = df.groupby(unit).agg({
             first_treat: 'first',

{diff_diff-2.3.1 → diff_diff-2.4.0}/diff_diff/sun_abraham.py

@@ -456,9 +456,9 @@ class SunAbraham:
         covariates : list, optional
             List of covariate column names to include in regression.
         min_pre_periods : int, default=1
-            Minimum number of pre-treatment periods to include in event study.
+            **Deprecated**: Accepted but ignored. Will be removed in a future version.
         min_post_periods : int, default=1
-            Minimum number of post-treatment periods to include in event study.
+            **Deprecated**: Accepted but ignored. Will be removed in a future version.
 
         Returns
         -------
@@ -470,6 +470,22 @@ class SunAbraham:
         ValueError
             If required columns are missing or data validation fails.
         """
+        # Deprecation warnings for unimplemented parameters
+        if min_pre_periods != 1:
+            warnings.warn(
+                "min_pre_periods is not yet implemented and will be ignored. "
+                "This parameter will be removed in a future version.",
+                FutureWarning,
+                stacklevel=2,
+            )
+        if min_post_periods != 1:
+            warnings.warn(
+                "min_post_periods is not yet implemented and will be ignored. "
+                "This parameter will be removed in a future version.",
+                FutureWarning,
+                stacklevel=2,
+            )
+
         # Validate inputs
         required_cols = [outcome, unit, time, first_treat]
         if covariates:
@@ -486,13 +502,15 @@ class SunAbraham:
         df[time] = pd.to_numeric(df[time])
         df[first_treat] = pd.to_numeric(df[first_treat])
 
+        # Never-treated indicator (must precede treatment_groups to exclude np.inf)
+        df["_never_treated"] = (df[first_treat] == 0) | (df[first_treat] == np.inf)
+        # Normalize np.inf → 0 so all downstream `> 0` checks exclude never-treated
+        df.loc[df[first_treat] == np.inf, first_treat] = 0
+
         # Identify groups and time periods
         time_periods = sorted(df[time].unique())
         treatment_groups = sorted([g for g in df[first_treat].unique() if g > 0])
 
-        # Never-treated indicator
-        df["_never_treated"] = (df[first_treat] == 0) | (df[first_treat] == np.inf)
-
         # Get unique units
         unit_info = (
             df.groupby(unit)
@@ -533,9 +551,9 @@ class SunAbraham:
 
         all_rel_times_sorted = sorted(all_rel_times)
 
-        # Filter to reasonable range
-        min_rel = max(min(all_rel_times_sorted), -20)  # cap at -20
-        max_rel = min(max(all_rel_times_sorted), 20)   # cap at +20
+        # Use full range of relative times (no artificial truncation, matches R's fixest::sunab())
+        min_rel = min(all_rel_times_sorted)
+        max_rel = max(all_rel_times_sorted)
 
         # Reference period: last pre-treatment period (typically -1)
         self._reference_period = -1 - self.anticipation
@@ -765,12 +783,18 @@ class SunAbraham:
 
         # Fit OLS using LinearRegression helper (more stable than manual X'X inverse)
         cluster_ids = df_demeaned[cluster_var].values
+
+        # Degrees of freedom adjustment for absorbed unit and time fixed effects
+        n_units_fe = df[unit].nunique()
+        n_times_fe = df[time].nunique()
+        df_adj = n_units_fe + n_times_fe - 1
+
         reg = LinearRegression(
             include_intercept=False,  # Already demeaned, no intercept needed
             robust=True,
             cluster_ids=cluster_ids,
             rank_deficient_action=self.rank_deficient_action,
-        ).fit(X, y)
+        ).fit(X, y, df_adjustment=df_adj)
 
         coefficients = reg.coefficients_
         vcov = reg.vcov_
@@ -821,7 +845,8 @@ class SunAbraham:
 
         β_e = Σ_g w_{g,e} × δ_{g,e}
 
-        where w_{g,e} is the share of cohort g among treated units at relative time e.
+        where w_{g,e} = n_{g,e} / Σ_g n_{g,e} is the share of observations from cohort g
+        at event-time e among all treated observations at that event-time.
 
         Returns
         -------
@@ -833,9 +858,8 @@ class SunAbraham:
         event_study_effects: Dict[int, Dict[str, Any]] = {}
         cohort_weights: Dict[int, Dict[Any, float]] = {}
 
-        # Get cohort sizes
-        unit_cohorts = df.groupby(unit)[first_treat].first()
-        cohort_sizes = unit_cohorts[unit_cohorts > 0].value_counts().to_dict()
+        # Pre-compute per-event-time observation counts: n_{g,e}
+        event_time_counts = df[df[first_treat] > 0].groupby([first_treat, "_rel_time"]).size()
 
         for e in rel_periods:
             # Get cohorts that have observations at this relative time
@@ -847,13 +871,13 @@ class SunAbraham:
             if not cohorts_at_e:
                 continue
 
-            # Compute IW weights: share of each cohort among those observed at e
+            # Compute IW weights: n_{g,e} / Σ_g n_{g,e}
             weights = {}
             total_size = 0
             for g in cohorts_at_e:
-                n_g = cohort_sizes.get(g, 0)
-                weights[g] = n_g
-                total_size += n_g
+                n_g_e = event_time_counts.get((g, e), 0)
+                weights[g] = n_g_e
+                total_size += n_g_e
 
             if total_size == 0:
                 continue
@@ -915,7 +939,7 @@ class SunAbraham:
         ]
 
         if not post_effects:
-            return 0.0, 0.0
+            return np.nan, np.nan
 
         # Weight by number of treated observations at each relative time
         post_weights = []
@@ -948,7 +972,13 @@ class SunAbraham:
                         overall_weights_by_coef[key] += period_weight * cw
 
         if not overall_weights_by_coef:
-            # Fallback to simple variance calculation
+            # Fallback to simplified variance that ignores covariances between periods
+            warnings.warn(
+                "Could not construct full weight vector for overall ATT SE. "
+                "Using simplified variance that ignores covariances between periods.",
+                UserWarning,
+                stacklevel=2,
+            )
             overall_var = float(
                 np.sum((post_weights ** 2) * np.array([eff["se"] ** 2 for _, eff in post_effects]))
             )
@@ -1029,6 +1059,7 @@ class SunAbraham:
                 df_b[time] - df_b[first_treat],
                 np.nan
             )
+            # np.inf was normalized to 0 in fit(), so the np.inf check is defensive only
             df_b["_never_treated"] = (
                 (df_b[first_treat] == 0) | (df_b[first_treat] == np.inf)
             )
@@ -1113,11 +1144,16 @@ class SunAbraham:
             event_study_p_values[e] = p_value
 
         # Overall ATT statistics
-        overall_se = float(np.std(bootstrap_overall, ddof=1))
-        overall_ci = self._compute_percentile_ci(bootstrap_overall, self.alpha)
-        overall_p = self._compute_bootstrap_pvalue(
-            original_overall_att, bootstrap_overall
-        )
+        if not np.isfinite(original_overall_att):
+            overall_se = np.nan
+            overall_ci = (np.nan, np.nan)
+            overall_p = np.nan
+        else:
+            overall_se = float(np.std(bootstrap_overall, ddof=1))
+            overall_ci = self._compute_percentile_ci(bootstrap_overall, self.alpha)
+            overall_p = self._compute_bootstrap_pvalue(
+                original_overall_att, bootstrap_overall
+            )
 
         return SABootstrapResults(
             n_bootstrap=self.n_bootstrap,