diff-diff 0.5.0__tar.gz → 0.6.0__tar.gz

{diff_diff-0.5.0 → diff_diff-0.6.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 0.5.0
+Version: 0.6.0
 Summary: A library for Difference-in-Differences causal inference analysis
 Author: diff-diff contributors
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/igerber/diff-diff
-Project-URL: Documentation, https://github.com/igerber/diff-diff#readme
+Project-URL: Documentation, https://diff-diff.readthedocs.io
 Project-URL: Repository, https://github.com/igerber/diff-diff
 Project-URL: Issues, https://github.com/igerber/diff-diff/issues
 Keywords: causal-inference,difference-in-differences,econometrics,statistics,treatment-effects
@@ -110,8 +110,21 @@ Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1
 - **Event study plots**: Publication-ready visualization of treatment effects
 - **Parallel trends testing**: Multiple methods including equivalence tests
 - **Placebo tests**: Comprehensive diagnostics including fake timing, fake group, permutation, and leave-one-out tests
+- **Honest DiD sensitivity analysis**: Rambachan-Roth (2023) bounds and breakdown analysis for parallel trends violations
 - **Data prep utilities**: Helper functions for common data preparation tasks
 
+## Tutorials
+
+We provide Jupyter notebook tutorials in `docs/tutorials/`:
+
+| Notebook | Description |
+|----------|-------------|
+| `01_basic_did.ipynb` | Basic 2x2 DiD, formula interface, covariates, fixed effects, cluster-robust SE, wild bootstrap |
+| `02_staggered_did.ipynb` | Staggered adoption with Callaway-Sant'Anna, group-time effects, aggregation methods |
+| `03_synthetic_did.ipynb` | Synthetic DiD, unit/time weights, inference methods, regularization |
+| `04_parallel_trends.ipynb` | Testing parallel trends, equivalence tests, placebo tests, diagnostics |
+| `05_honest_did.ipynb` | Honest DiD sensitivity analysis, bounds, breakdown values, visualization |
+
 ## Data Preparation
 
 diff-diff provides utility functions to help prepare your data for DiD analysis. These functions handle common data transformation tasks like creating treatment indicators, reshaping panel data, and validating data formats.
@@ -720,14 +733,31 @@ CallawaySantAnna(
     estimation_method='dr',          # 'dr', 'ipw', or 'reg'
     alpha=0.05,                      # Significance level
     cluster=None,                    # Column for cluster SEs
-    n_bootstrap=0,                   # Must be 0 (bootstrap not yet implemented)
+    n_bootstrap=0,                   # Bootstrap iterations (0 = analytical SEs)
     seed=None                        # Random seed
 )
 ```
 
+**Covariate adjustment for conditional parallel trends:**
+
+When parallel trends only holds conditional on covariates, use the `covariates` parameter:
+
+```python
+# Doubly robust estimation with covariates
+cs = CallawaySantAnna(estimation_method='dr')  # 'dr', 'ipw', or 'reg'
+results = cs.fit(
+    data,
+    outcome='sales',
+    unit='firm_id',
+    time='year',
+    first_treat='first_treat',
+    covariates=['size', 'age', 'industry'],  # Covariates for conditional PT
+    aggregate='event_study'
+)
+```
+
 **Current limitations:**
-- Bootstrap inference (`n_bootstrap > 0`) is not yet implemented
-- Covariate adjustment for conditional parallel trends is not yet implemented
+- Bootstrap inference (`n_bootstrap > 0`) is not yet fully implemented
 
 ### Event Study Visualization
 
@@ -1004,6 +1034,81 @@ print(f"TOST p-value: {results['tost_p_value']:.4f}")
 print(f"Trends equivalent: {results['equivalent']}")
 ```
 
+### Honest DiD Sensitivity Analysis (Rambachan-Roth)
+
+Pre-trends tests have low power and can exacerbate bias. **Honest DiD** (Rambachan & Roth 2023) provides sensitivity analysis showing how robust your results are to violations of parallel trends.
+
+```python
+from diff_diff import HonestDiD, MultiPeriodDiD
+
+# First, fit a standard event study
+did = MultiPeriodDiD()
+event_results = did.fit(
+    data,
+    outcome='outcome',
+    treatment='treated',
+    time='period',
+    post_periods=[5, 6, 7, 8, 9]
+)
+
+# Compute honest bounds with relative magnitudes restriction
+# M=1 means post-treatment violations can be up to 1x the worst pre-treatment violation
+honest = HonestDiD(method='relative_magnitude', M=1.0)
+honest_results = honest.fit(event_results)
+
+print(honest_results.summary())
+print(f"Original estimate: {honest_results.original_estimate:.4f}")
+print(f"Robust 95% CI: [{honest_results.ci_lb:.4f}, {honest_results.ci_ub:.4f}]")
+print(f"Effect robust to violations: {honest_results.is_significant}")
+```
+
+**Sensitivity analysis over M values:**
+
+```python
+# How do results change as we allow larger violations?
+sensitivity = honest.sensitivity_analysis(
+    event_results,
+    M_grid=[0, 0.5, 1.0, 1.5, 2.0]
+)
+
+print(sensitivity.summary())
+print(f"Breakdown value: M = {sensitivity.breakdown_M}")
+# Breakdown = smallest M where the robust CI includes zero
+```
+
+**Breakdown value:**
+
+The breakdown value tells you how robust your conclusion is:
+
+```python
+breakdown = honest.breakdown_value(event_results)
+if breakdown >= 1.0:
+    print("Result holds even if post-treatment violations are as bad as pre-treatment")
+else:
+    print(f"Result requires violations smaller than {breakdown:.1f}x pre-treatment")
+```
+
+**Smoothness restriction (alternative approach):**
+
+```python
+# Bounds second differences of trend violations
+# M=0 means linear extrapolation of pre-trends
+honest_smooth = HonestDiD(method='smoothness', M=0.5)
+smooth_results = honest_smooth.fit(event_results)
+```
+
+**Visualization:**
+
+```python
+from diff_diff import plot_sensitivity, plot_honest_event_study
+
+# Plot sensitivity analysis
+plot_sensitivity(sensitivity, title="Sensitivity to Parallel Trends Violations")
+
+# Event study with honest confidence intervals
+plot_honest_event_study(event_results, honest_results)
+```
+
 ### Placebo Tests
 
 Placebo tests help validate the parallel trends assumption by checking whether effects appear where they shouldn't (before treatment or in untreated groups).
@@ -1302,6 +1407,75 @@ SyntheticDiD(
 | `get_unit_weights_df()` | Get unit weights as DataFrame |
 | `get_time_weights_df()` | Get time weights as DataFrame |
 
+### HonestDiD
+
+```python
+HonestDiD(
+    method='relative_magnitude',  # 'relative_magnitude' or 'smoothness'
+    M=None,               # Restriction parameter (default: 1.0 for RM, 0.0 for SD)
+    alpha=0.05,           # Significance level for CIs
+    l_vec=None            # Linear combination vector for target parameter
+)
+```
+
+**fit() Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `results` | MultiPeriodDiDResults | Results from MultiPeriodDiD.fit() |
+| `M` | float | Restriction parameter (overrides constructor value) |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `fit(results, M)` | Compute bounds for given event study results |
+| `sensitivity_analysis(results, M_grid)` | Compute bounds over grid of M values |
+| `breakdown_value(results, tol)` | Find smallest M where CI includes zero |
+
+### HonestDiDResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `original_estimate` | Point estimate under parallel trends |
+| `lb` | Lower bound of identified set |
+| `ub` | Upper bound of identified set |
+| `ci_lb` | Lower bound of robust confidence interval |
+| `ci_ub` | Upper bound of robust confidence interval |
+| `ci_width` | Width of robust CI |
+| `M` | Restriction parameter used |
+| `method` | Restriction method ('relative_magnitude' or 'smoothness') |
+| `alpha` | Significance level |
+| `is_significant` | True if robust CI excludes zero |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `summary()` | Get formatted summary string |
+| `to_dict()` | Convert to dictionary |
+| `to_dataframe()` | Convert to pandas DataFrame |
+
+### SensitivityResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `M_grid` | Array of M values analyzed |
+| `results` | List of HonestDiDResults for each M |
+| `breakdown_M` | Smallest M where CI includes zero (None if always significant) |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `summary()` | Get formatted summary string |
+| `plot(ax)` | Plot sensitivity analysis |
+| `to_dataframe()` | Convert to pandas DataFrame |
+
 ### Data Preparation Functions
 
 #### generate_did_data
@@ -1525,9 +1699,23 @@ This library implements methods from the following scholarly works:
 
 - **Roth, J. (2022).** "Pretest with Caution: Event-Study Estimates after Testing for Parallel Trends." *American Economic Review: Insights*, 4(3), 305-322. [https://doi.org/10.1257/aeri.20210236](https://doi.org/10.1257/aeri.20210236)
 
+- **Lakens, D. (2017).** "Equivalence Tests: A Practical Primer for t Tests, Correlations, and Meta-Analyses." *Social Psychological and Personality Science*, 8(4), 355-362. [https://doi.org/10.1177/1948550617697177](https://doi.org/10.1177/1948550617697177)
+
+### Honest DiD / Sensitivity Analysis
+
+The `HonestDiD` module implements sensitivity analysis methods for relaxing the parallel trends assumption:
+
 - **Rambachan, A., & Roth, J. (2023).** "A More Credible Approach to Parallel Trends." *The Review of Economic Studies*, 90(5), 2555-2591. [https://doi.org/10.1093/restud/rdad018](https://doi.org/10.1093/restud/rdad018)
 
-- **Lakens, D. (2017).** "Equivalence Tests: A Practical Primer for t Tests, Correlations, and Meta-Analyses." *Social Psychological and Personality Science*, 8(4), 355-362. [https://doi.org/10.1177/1948550617697177](https://doi.org/10.1177/1948550617697177)
+  This paper introduces the "Honest DiD" framework implemented in our `HonestDiD` class:
+  - **Relative Magnitudes (ΔRM)**: Bounds post-treatment violations by a multiple of observed pre-treatment violations
+  - **Smoothness (ΔSD)**: Bounds on second differences of trend violations, allowing for linear extrapolation of pre-trends
+  - **Breakdown Analysis**: Finding the smallest violation magnitude that would overturn conclusions
+  - **Robust Confidence Intervals**: Valid inference under partial identification
+
+- **Roth, J., & Sant'Anna, P. H. C. (2023).** "When Is Parallel Trends Sensitive to Functional Form?" *Econometrica*, 91(2), 737-747. [https://doi.org/10.3982/ECTA19402](https://doi.org/10.3982/ECTA19402)
+
+  Discusses functional form sensitivity in parallel trends assumptions, relevant to understanding when smoothness restrictions are appropriate.
 
 ### Multi-Period and Staggered Adoption
 

{diff_diff-0.5.0 → diff_diff-0.6.0}/README.md

@@ -75,8 +75,21 @@ Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1
 - **Event study plots**: Publication-ready visualization of treatment effects
 - **Parallel trends testing**: Multiple methods including equivalence tests
 - **Placebo tests**: Comprehensive diagnostics including fake timing, fake group, permutation, and leave-one-out tests
+- **Honest DiD sensitivity analysis**: Rambachan-Roth (2023) bounds and breakdown analysis for parallel trends violations
 - **Data prep utilities**: Helper functions for common data preparation tasks
 
+## Tutorials
+
+We provide Jupyter notebook tutorials in `docs/tutorials/`:
+
+| Notebook | Description |
+|----------|-------------|
+| `01_basic_did.ipynb` | Basic 2x2 DiD, formula interface, covariates, fixed effects, cluster-robust SE, wild bootstrap |
+| `02_staggered_did.ipynb` | Staggered adoption with Callaway-Sant'Anna, group-time effects, aggregation methods |
+| `03_synthetic_did.ipynb` | Synthetic DiD, unit/time weights, inference methods, regularization |
+| `04_parallel_trends.ipynb` | Testing parallel trends, equivalence tests, placebo tests, diagnostics |
+| `05_honest_did.ipynb` | Honest DiD sensitivity analysis, bounds, breakdown values, visualization |
+
 ## Data Preparation
 
 diff-diff provides utility functions to help prepare your data for DiD analysis. These functions handle common data transformation tasks like creating treatment indicators, reshaping panel data, and validating data formats.
@@ -685,14 +698,31 @@ CallawaySantAnna(
     estimation_method='dr',          # 'dr', 'ipw', or 'reg'
     alpha=0.05,                      # Significance level
     cluster=None,                    # Column for cluster SEs
-    n_bootstrap=0,                   # Must be 0 (bootstrap not yet implemented)
+    n_bootstrap=0,                   # Bootstrap iterations (0 = analytical SEs)
     seed=None                        # Random seed
 )
 ```
 
+**Covariate adjustment for conditional parallel trends:**
+
+When parallel trends only holds conditional on covariates, use the `covariates` parameter:
+
+```python
+# Doubly robust estimation with covariates
+cs = CallawaySantAnna(estimation_method='dr')  # 'dr', 'ipw', or 'reg'
+results = cs.fit(
+    data,
+    outcome='sales',
+    unit='firm_id',
+    time='year',
+    first_treat='first_treat',
+    covariates=['size', 'age', 'industry'],  # Covariates for conditional PT
+    aggregate='event_study'
+)
+```
+
 **Current limitations:**
-- Bootstrap inference (`n_bootstrap > 0`) is not yet implemented
-- Covariate adjustment for conditional parallel trends is not yet implemented
+- Bootstrap inference (`n_bootstrap > 0`) is not yet fully implemented
 
 ### Event Study Visualization
 
@@ -969,6 +999,81 @@ print(f"TOST p-value: {results['tost_p_value']:.4f}")
 print(f"Trends equivalent: {results['equivalent']}")
 ```
 
+### Honest DiD Sensitivity Analysis (Rambachan-Roth)
+
+Pre-trends tests have low power and can exacerbate bias. **Honest DiD** (Rambachan & Roth 2023) provides sensitivity analysis showing how robust your results are to violations of parallel trends.
+
+```python
+from diff_diff import HonestDiD, MultiPeriodDiD
+
+# First, fit a standard event study
+did = MultiPeriodDiD()
+event_results = did.fit(
+    data,
+    outcome='outcome',
+    treatment='treated',
+    time='period',
+    post_periods=[5, 6, 7, 8, 9]
+)
+
+# Compute honest bounds with relative magnitudes restriction
+# M=1 means post-treatment violations can be up to 1x the worst pre-treatment violation
+honest = HonestDiD(method='relative_magnitude', M=1.0)
+honest_results = honest.fit(event_results)
+
+print(honest_results.summary())
+print(f"Original estimate: {honest_results.original_estimate:.4f}")
+print(f"Robust 95% CI: [{honest_results.ci_lb:.4f}, {honest_results.ci_ub:.4f}]")
+print(f"Effect robust to violations: {honest_results.is_significant}")
+```
+
+**Sensitivity analysis over M values:**
+
+```python
+# How do results change as we allow larger violations?
+sensitivity = honest.sensitivity_analysis(
+    event_results,
+    M_grid=[0, 0.5, 1.0, 1.5, 2.0]
+)
+
+print(sensitivity.summary())
+print(f"Breakdown value: M = {sensitivity.breakdown_M}")
+# Breakdown = smallest M where the robust CI includes zero
+```
+
+**Breakdown value:**
+
+The breakdown value tells you how robust your conclusion is:
+
+```python
+breakdown = honest.breakdown_value(event_results)
+if breakdown >= 1.0:
+    print("Result holds even if post-treatment violations are as bad as pre-treatment")
+else:
+    print(f"Result requires violations smaller than {breakdown:.1f}x pre-treatment")
+```
+
+**Smoothness restriction (alternative approach):**
+
+```python
+# Bounds second differences of trend violations
+# M=0 means linear extrapolation of pre-trends
+honest_smooth = HonestDiD(method='smoothness', M=0.5)
+smooth_results = honest_smooth.fit(event_results)
+```
+
+**Visualization:**
+
+```python
+from diff_diff import plot_sensitivity, plot_honest_event_study
+
+# Plot sensitivity analysis
+plot_sensitivity(sensitivity, title="Sensitivity to Parallel Trends Violations")
+
+# Event study with honest confidence intervals
+plot_honest_event_study(event_results, honest_results)
+```
+
 ### Placebo Tests
 
 Placebo tests help validate the parallel trends assumption by checking whether effects appear where they shouldn't (before treatment or in untreated groups).
@@ -1267,6 +1372,75 @@ SyntheticDiD(
 | `get_unit_weights_df()` | Get unit weights as DataFrame |
 | `get_time_weights_df()` | Get time weights as DataFrame |
 
+### HonestDiD
+
+```python
+HonestDiD(
+    method='relative_magnitude',  # 'relative_magnitude' or 'smoothness'
+    M=None,               # Restriction parameter (default: 1.0 for RM, 0.0 for SD)
+    alpha=0.05,           # Significance level for CIs
+    l_vec=None            # Linear combination vector for target parameter
+)
+```
+
+**fit() Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `results` | MultiPeriodDiDResults | Results from MultiPeriodDiD.fit() |
+| `M` | float | Restriction parameter (overrides constructor value) |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `fit(results, M)` | Compute bounds for given event study results |
+| `sensitivity_analysis(results, M_grid)` | Compute bounds over grid of M values |
+| `breakdown_value(results, tol)` | Find smallest M where CI includes zero |
+
+### HonestDiDResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `original_estimate` | Point estimate under parallel trends |
+| `lb` | Lower bound of identified set |
+| `ub` | Upper bound of identified set |
+| `ci_lb` | Lower bound of robust confidence interval |
+| `ci_ub` | Upper bound of robust confidence interval |
+| `ci_width` | Width of robust CI |
+| `M` | Restriction parameter used |
+| `method` | Restriction method ('relative_magnitude' or 'smoothness') |
+| `alpha` | Significance level |
+| `is_significant` | True if robust CI excludes zero |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `summary()` | Get formatted summary string |
+| `to_dict()` | Convert to dictionary |
+| `to_dataframe()` | Convert to pandas DataFrame |
+
+### SensitivityResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `M_grid` | Array of M values analyzed |
+| `results` | List of HonestDiDResults for each M |
+| `breakdown_M` | Smallest M where CI includes zero (None if always significant) |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `summary()` | Get formatted summary string |
+| `plot(ax)` | Plot sensitivity analysis |
+| `to_dataframe()` | Convert to pandas DataFrame |
+
 ### Data Preparation Functions
 
 #### generate_did_data
@@ -1490,9 +1664,23 @@ This library implements methods from the following scholarly works:
 
 - **Roth, J. (2022).** "Pretest with Caution: Event-Study Estimates after Testing for Parallel Trends." *American Economic Review: Insights*, 4(3), 305-322. [https://doi.org/10.1257/aeri.20210236](https://doi.org/10.1257/aeri.20210236)
 
+- **Lakens, D. (2017).** "Equivalence Tests: A Practical Primer for t Tests, Correlations, and Meta-Analyses." *Social Psychological and Personality Science*, 8(4), 355-362. [https://doi.org/10.1177/1948550617697177](https://doi.org/10.1177/1948550617697177)
+
+### Honest DiD / Sensitivity Analysis
+
+The `HonestDiD` module implements sensitivity analysis methods for relaxing the parallel trends assumption:
+
 - **Rambachan, A., & Roth, J. (2023).** "A More Credible Approach to Parallel Trends." *The Review of Economic Studies*, 90(5), 2555-2591. [https://doi.org/10.1093/restud/rdad018](https://doi.org/10.1093/restud/rdad018)
 
-- **Lakens, D. (2017).** "Equivalence Tests: A Practical Primer for t Tests, Correlations, and Meta-Analyses." *Social Psychological and Personality Science*, 8(4), 355-362. [https://doi.org/10.1177/1948550617697177](https://doi.org/10.1177/1948550617697177)
+  This paper introduces the "Honest DiD" framework implemented in our `HonestDiD` class:
+  - **Relative Magnitudes (ΔRM)**: Bounds post-treatment violations by a multiple of observed pre-treatment violations
+  - **Smoothness (ΔSD)**: Bounds on second differences of trend violations, allowing for linear extrapolation of pre-trends
+  - **Breakdown Analysis**: Finding the smallest violation magnitude that would overturn conclusions
+  - **Robust Confidence Intervals**: Valid inference under partial identification
+
+- **Roth, J., & Sant'Anna, P. H. C. (2023).** "When Is Parallel Trends Sensitive to Functional Form?" *Econometrica*, 91(2), 737-747. [https://doi.org/10.3982/ECTA19402](https://doi.org/10.3982/ECTA19402)
+
+  Discusses functional form sensitivity in parallel trends assumptions, relevant to understanding when smoothness restrictions are appropriate.
 
 ### Multi-Period and Staggered Adoption
 

{diff_diff-0.5.0 → diff_diff-0.6.0}/diff_diff/__init__.py

@@ -5,16 +5,42 @@ This library provides sklearn-like estimators for causal inference
 using the difference-in-differences methodology.
 """
 
+from diff_diff.diagnostics import (
+    PlaceboTestResults,
+    leave_one_out_test,
+    permutation_test,
+    placebo_group_test,
+    placebo_timing_test,
+    run_all_placebo_tests,
+    run_placebo_test,
+)
 from diff_diff.estimators import (
     DifferenceInDifferences,
-    TwoWayFixedEffects,
     MultiPeriodDiD,
     SyntheticDiD,
+    TwoWayFixedEffects,
 )
-from diff_diff.staggered import (
-    CallawaySantAnna,
-    CallawaySantAnnaResults,
-    GroupTimeEffect,
+from diff_diff.honest_did import (
+    DeltaRM,
+    DeltaSD,
+    DeltaSDRM,
+    HonestDiD,
+    HonestDiDResults,
+    SensitivityResults,
+    compute_honest_did,
+    sensitivity_plot,
+)
+from diff_diff.prep import (
+    aggregate_to_cohorts,
+    balance_panel,
+    create_event_time,
+    generate_did_data,
+    make_post_indicator,
+    make_treatment_indicator,
+    rank_control_units,
+    summarize_did_data,
+    validate_did_data,
+    wide_to_long,
 )
 from diff_diff.results import (
     DiDResults,
@@ -22,40 +48,26 @@ from diff_diff.results import (
     PeriodEffect,
     SyntheticDiDResults,
 )
-from diff_diff.visualization import (
-    plot_event_study,
-    plot_group_effects,
-)
-from diff_diff.prep import (
-    make_treatment_indicator,
-    make_post_indicator,
-    wide_to_long,
-    balance_panel,
-    validate_did_data,
-    summarize_did_data,
-    generate_did_data,
-    create_event_time,
-    aggregate_to_cohorts,
-    rank_control_units,
+from diff_diff.staggered import (
+    CallawaySantAnna,
+    CallawaySantAnnaResults,
+    GroupTimeEffect,
 )
 from diff_diff.utils import (
+    WildBootstrapResults,
     check_parallel_trends,
     check_parallel_trends_robust,
     equivalence_test_trends,
-    WildBootstrapResults,
     wild_bootstrap_se,
 )
-from diff_diff.diagnostics import (
-    PlaceboTestResults,
-    run_placebo_test,
-    placebo_timing_test,
-    placebo_group_test,
-    permutation_test,
-    leave_one_out_test,
-    run_all_placebo_tests,
+from diff_diff.visualization import (
+    plot_event_study,
+    plot_group_effects,
+    plot_honest_event_study,
+    plot_sensitivity,
 )
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",
@@ -73,6 +85,8 @@ __all__ = [
     # Visualization
     "plot_event_study",
     "plot_group_effects",
+    "plot_sensitivity",
+    "plot_honest_event_study",
     # Parallel trends testing
     "check_parallel_trends",
     "check_parallel_trends_robust",
@@ -99,4 +113,13 @@ __all__ = [
     "create_event_time",
     "aggregate_to_cohorts",
     "rank_control_units",
+    # Honest DiD sensitivity analysis
+    "HonestDiD",
+    "HonestDiDResults",
+    "SensitivityResults",
+    "DeltaSD",
+    "DeltaRM",
+    "DeltaSDRM",
+    "compute_honest_did",
+    "sensitivity_plot",
 ]

{diff_diff-0.5.0 → diff_diff-0.6.0}/diff_diff/diagnostics.py

@@ -360,6 +360,9 @@ def run_placebo_test(
             **estimator_kwargs
         )
 
+    # This should never be reached due to validation above
+    raise ValueError(f"Unknown test type: {test_type}")
+
 
 def placebo_timing_test(
     data: pd.DataFrame,

{diff_diff-0.5.0 → diff_diff-0.6.0}/diff_diff/estimators.py

@@ -603,6 +603,7 @@ class DifferenceInDifferences:
         """
         if not self.is_fitted_:
             raise RuntimeError("Model must be fitted before calling summary()")
+        assert self.results_ is not None
         return self.results_.summary()
 
     def print_summary(self) -> None:
@@ -641,7 +642,7 @@ class TwoWayFixedEffects(DifferenceInDifferences):
     staggered designs.
     """
 
-    def fit(
+    def fit(  # type: ignore[override]
         self,
         data: pd.DataFrame,
         outcome: str,
@@ -763,7 +764,7 @@ class TwoWayFixedEffects(DifferenceInDifferences):
             n_treated=n_treated,
             n_control=n_control,
             alpha=self.alpha,
-            coefficients={"ATT": att},
+            coefficients={"ATT": float(att)},
             vcov=vcov,
             residuals=residuals,
             fitted_values=fitted,
@@ -892,7 +893,7 @@ class MultiPeriodDiD(DifferenceInDifferences):
     The average ATT is computed as the mean of the δ_t coefficients.
     """
 
-    def fit(
+    def fit(  # type: ignore[override]
         self,
         data: pd.DataFrame,
         outcome: str,
@@ -1166,6 +1167,7 @@ class MultiPeriodDiD(DifferenceInDifferences):
         """
         if not self.is_fitted_:
             raise RuntimeError("Model must be fitted before calling summary()")
+        assert self.results_ is not None
         return self.results_.summary()
 
 
@@ -1284,7 +1286,7 @@ class SyntheticDiD(DifferenceInDifferences):
         self._unit_weights = None
         self._time_weights = None
 
-    def fit(
+    def fit(  # type: ignore[override]
         self,
         data: pd.DataFrame,
         outcome: str,