diff-diff 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

diff_diff/__init__.py

@@ -5,8 +5,14 @@ This library provides sklearn-like estimators for causal inference
 using the difference-in-differences methodology.
 """
 
-from diff_diff.estimators import DifferenceInDifferences
-from diff_diff.results import DiDResults
+from diff_diff.estimators import DifferenceInDifferences, MultiPeriodDiD
+from diff_diff.results import DiDResults, MultiPeriodDiDResults, PeriodEffect
 
-__version__ = "0.1.0"
-__all__ = ["DifferenceInDifferences", "DiDResults"]
+__version__ = "0.2.0"
+__all__ = [
+    "DifferenceInDifferences",
+    "MultiPeriodDiD",
+    "DiDResults",
+    "MultiPeriodDiDResults",
+    "PeriodEffect",
+]

diff_diff/estimators.py

@@ -8,7 +8,7 @@ import numpy as np
 import pandas as pd
 from scipy import stats
 
-from diff_diff.results import DiDResults
+from diff_diff.results import DiDResults, MultiPeriodDiDResults, PeriodEffect
 from diff_diff.utils import (
     validate_binary,
     compute_robust_se,
@@ -169,6 +169,10 @@ class DifferenceInDifferences:
         # Validate inputs
         self._validate_data(data, outcome, treatment, time, covariates)
 
+        # Validate binary variables BEFORE any transformations
+        validate_binary(data[treatment].values, "treatment")
+        validate_binary(data[time].values, "time")
+
         # Validate fixed effects and absorb columns
         if fixed_effects:
             for fe in fixed_effects:
@@ -186,6 +190,9 @@ class DifferenceInDifferences:
 
         if absorb:
             # Apply within-transformation for each absorbed variable
+            # Only demean outcome and covariates, NOT treatment/time indicators
+            # Treatment is typically time-invariant (within unit), and time is
+            # unit-invariant, so demeaning them would create multicollinearity
             vars_to_demean = [outcome] + (covariates or [])
             for ab_var in absorb:
                 n_absorbed_effects += working_data[ab_var].nunique() - 1
@@ -194,15 +201,11 @@ class DifferenceInDifferences:
                     working_data[var] = working_data[var] - group_means
                 absorbed_vars.append(ab_var)
 
-        # Extract variables
+        # Extract variables (may be demeaned if absorb was used)
         y = working_data[outcome].values.astype(float)
         d = working_data[treatment].values.astype(float)
         t = working_data[time].values.astype(float)
 
-        # Validate binary variables
-        validate_binary(d, "treatment")
-        validate_binary(t, "time")
-
         # Create interaction term
         dt = d * t
 
@@ -220,7 +223,8 @@ class DifferenceInDifferences:
         if fixed_effects:
             for fe in fixed_effects:
                 # Create dummies, drop first category to avoid multicollinearity
-                dummies = pd.get_dummies(data[fe], prefix=fe, drop_first=True)
+                # Use working_data to be consistent with absorbed FE if both are used
+                dummies = pd.get_dummies(working_data[fe], prefix=fe, drop_first=True)
                 for col in dummies.columns:
                     X = np.column_stack([X, dummies[col].values.astype(float)])
                     var_names.append(col)
@@ -298,7 +302,21 @@ class DifferenceInDifferences:
         -------
         tuple
             (coefficients, residuals, fitted_values, r_squared)
+
+        Raises
+        ------
+        ValueError
+            If design matrix is rank-deficient (perfect multicollinearity).
         """
+        # Check for rank deficiency (perfect multicollinearity)
+        rank = np.linalg.matrix_rank(X)
+        if rank < X.shape[1]:
+            raise ValueError(
+                f"Design matrix is rank-deficient (rank {rank} < {X.shape[1]} columns). "
+                "This indicates perfect multicollinearity. Check your fixed effects "
+                "and covariates for linear dependencies."
+            )
+
         # Solve normal equations: β = (X'X)^(-1) X'y
         coefficients = np.linalg.lstsq(X, y, rcond=None)[0]
 
@@ -699,3 +717,334 @@ class TwoWayFixedEffects(DifferenceInDifferences):
             data[f"{var}_demeaned"] = data[var] - unit_means - time_means + grand_mean
 
         return data
+
+
+class MultiPeriodDiD(DifferenceInDifferences):
+    """
+    Multi-Period Difference-in-Differences estimator.
+
+    Extends the standard DiD to handle multiple pre-treatment and
+    post-treatment time periods, providing period-specific treatment
+    effects as well as an aggregate average treatment effect.
+
+    Parameters
+    ----------
+    robust : bool, default=True
+        Whether to use heteroskedasticity-robust standard errors (HC1).
+    cluster : str, optional
+        Column name for cluster-robust standard errors.
+    alpha : float, default=0.05
+        Significance level for confidence intervals.
+
+    Attributes
+    ----------
+    results_ : MultiPeriodDiDResults
+        Estimation results after calling fit().
+    is_fitted_ : bool
+        Whether the model has been fitted.
+
+    Examples
+    --------
+    Basic usage with multiple time periods:
+
+    >>> import pandas as pd
+    >>> from diff_diff import MultiPeriodDiD
+    >>>
+    >>> # Create sample panel data with 6 time periods
+    >>> # Periods 0-2 are pre-treatment, periods 3-5 are post-treatment
+    >>> data = create_panel_data()  # Your data
+    >>>
+    >>> # Fit the model
+    >>> did = MultiPeriodDiD()
+    >>> results = did.fit(
+    ...     data,
+    ...     outcome='sales',
+    ...     treatment='treated',
+    ...     time='period',
+    ...     post_periods=[3, 4, 5]  # Specify which periods are post-treatment
+    ... )
+    >>>
+    >>> # View period-specific effects
+    >>> for period, effect in results.period_effects.items():
+    ...     print(f"Period {period}: {effect.effect:.3f} (SE: {effect.se:.3f})")
+    >>>
+    >>> # View average treatment effect
+    >>> print(f"Average ATT: {results.avg_att:.3f}")
+
+    Notes
+    -----
+    The model estimates:
+
+        Y_it = α + β*D_i + Σ_t γ_t*Period_t + Σ_t∈post δ_t*(D_i × Post_t) + ε_it
+
+    Where:
+    - D_i is the treatment indicator
+    - Period_t are time period dummies
+    - D_i × Post_t are treatment-by-post-period interactions
+    - δ_t are the period-specific treatment effects
+
+    The average ATT is computed as the mean of the δ_t coefficients.
+    """
+
+    def fit(
+        self,
+        data: pd.DataFrame,
+        outcome: str,
+        treatment: str,
+        time: str,
+        post_periods: list = None,
+        covariates: list = None,
+        fixed_effects: list = None,
+        absorb: list = None,
+        reference_period: any = None
+    ) -> MultiPeriodDiDResults:
+        """
+        Fit the Multi-Period Difference-in-Differences model.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            DataFrame containing the outcome, treatment, and time variables.
+        outcome : str
+            Name of the outcome variable column.
+        treatment : str
+            Name of the treatment group indicator column (0/1).
+        time : str
+            Name of the time period column (can have multiple values).
+        post_periods : list
+            List of time period values that are post-treatment.
+            All other periods are treated as pre-treatment.
+        covariates : list, optional
+            List of covariate column names to include as linear controls.
+        fixed_effects : list, optional
+            List of categorical column names to include as fixed effects.
+        absorb : list, optional
+            List of categorical column names for high-dimensional fixed effects.
+        reference_period : any, optional
+            The reference (omitted) time period for the period dummies.
+            Defaults to the first pre-treatment period.
+
+        Returns
+        -------
+        MultiPeriodDiDResults
+            Object containing period-specific and average treatment effects.
+
+        Raises
+        ------
+        ValueError
+            If required parameters are missing or data validation fails.
+        """
+        # Validate basic inputs
+        if outcome is None or treatment is None or time is None:
+            raise ValueError(
+                "Must provide 'outcome', 'treatment', and 'time'"
+            )
+
+        # Validate columns exist
+        self._validate_data(data, outcome, treatment, time, covariates)
+
+        # Validate treatment is binary
+        validate_binary(data[treatment].values, "treatment")
+
+        # Get all unique time periods
+        all_periods = sorted(data[time].unique())
+
+        if len(all_periods) < 2:
+            raise ValueError("Time variable must have at least 2 unique periods")
+
+        # Determine pre and post periods
+        if post_periods is None:
+            # Default: last half of periods are post-treatment
+            mid_point = len(all_periods) // 2
+            post_periods = all_periods[mid_point:]
+            pre_periods = all_periods[:mid_point]
+        else:
+            post_periods = list(post_periods)
+            pre_periods = [p for p in all_periods if p not in post_periods]
+
+        if len(post_periods) == 0:
+            raise ValueError("Must have at least one post-treatment period")
+
+        if len(pre_periods) == 0:
+            raise ValueError("Must have at least one pre-treatment period")
+
+        # Validate post_periods are in the data
+        for p in post_periods:
+            if p not in all_periods:
+                raise ValueError(f"Post-period '{p}' not found in time column")
+
+        # Determine reference period (omitted dummy)
+        if reference_period is None:
+            reference_period = pre_periods[0]
+        elif reference_period not in all_periods:
+            raise ValueError(f"Reference period '{reference_period}' not found in time column")
+
+        # Validate fixed effects and absorb columns
+        if fixed_effects:
+            for fe in fixed_effects:
+                if fe not in data.columns:
+                    raise ValueError(f"Fixed effect column '{fe}' not found in data")
+        if absorb:
+            for ab in absorb:
+                if ab not in data.columns:
+                    raise ValueError(f"Absorb column '{ab}' not found in data")
+
+        # Handle absorbed fixed effects (within-transformation)
+        working_data = data.copy()
+        n_absorbed_effects = 0
+
+        if absorb:
+            vars_to_demean = [outcome] + (covariates or [])
+            for ab_var in absorb:
+                n_absorbed_effects += working_data[ab_var].nunique() - 1
+                for var in vars_to_demean:
+                    group_means = working_data.groupby(ab_var)[var].transform("mean")
+                    working_data[var] = working_data[var] - group_means
+
+        # Extract outcome and treatment
+        y = working_data[outcome].values.astype(float)
+        d = working_data[treatment].values.astype(float)
+        t = working_data[time].values
+
+        # Build design matrix
+        # Start with intercept and treatment main effect
+        X = np.column_stack([np.ones(len(y)), d])
+        var_names = ["const", treatment]
+
+        # Add period dummies (excluding reference period)
+        non_ref_periods = [p for p in all_periods if p != reference_period]
+        period_dummy_indices = {}  # Map period -> column index in X
+
+        for period in non_ref_periods:
+            period_dummy = (t == period).astype(float)
+            X = np.column_stack([X, period_dummy])
+            var_names.append(f"period_{period}")
+            period_dummy_indices[period] = X.shape[1] - 1
+
+        # Add treatment × post-period interactions
+        # These are our coefficients of interest
+        interaction_indices = {}  # Map post-period -> column index in X
+
+        for period in post_periods:
+            interaction = d * (t == period).astype(float)
+            X = np.column_stack([X, interaction])
+            var_names.append(f"{treatment}:period_{period}")
+            interaction_indices[period] = X.shape[1] - 1
+
+        # Add covariates if provided
+        if covariates:
+            for cov in covariates:
+                X = np.column_stack([X, working_data[cov].values.astype(float)])
+                var_names.append(cov)
+
+        # Add fixed effects as dummy variables
+        if fixed_effects:
+            for fe in fixed_effects:
+                dummies = pd.get_dummies(working_data[fe], prefix=fe, drop_first=True)
+                for col in dummies.columns:
+                    X = np.column_stack([X, dummies[col].values.astype(float)])
+                    var_names.append(col)
+
+        # Fit OLS
+        coefficients, residuals, fitted, r_squared = self._fit_ols(X, y)
+
+        # Compute standard errors
+        if self.cluster is not None:
+            cluster_ids = data[self.cluster].values
+            vcov = compute_robust_se(X, residuals, cluster_ids)
+        elif self.robust:
+            vcov = compute_robust_se(X, residuals)
+        else:
+            n = len(y)
+            k = X.shape[1]
+            mse = np.sum(residuals ** 2) / (n - k)
+            vcov = mse * np.linalg.inv(X.T @ X)
+
+        # Degrees of freedom
+        df = len(y) - X.shape[1] - n_absorbed_effects
+
+        # Extract period-specific treatment effects
+        period_effects = {}
+        effect_values = []
+        effect_indices = []
+
+        for period in post_periods:
+            idx = interaction_indices[period]
+            effect = coefficients[idx]
+            se = np.sqrt(vcov[idx, idx])
+            t_stat = effect / se
+            p_value = compute_p_value(t_stat, df=df)
+            conf_int = compute_confidence_interval(effect, se, self.alpha, df=df)
+
+            period_effects[period] = PeriodEffect(
+                period=period,
+                effect=effect,
+                se=se,
+                t_stat=t_stat,
+                p_value=p_value,
+                conf_int=conf_int
+            )
+            effect_values.append(effect)
+            effect_indices.append(idx)
+
+        # Compute average treatment effect
+        # Average ATT = mean of period-specific effects
+        avg_att = np.mean(effect_values)
+
+        # Standard error of average: need to account for covariance
+        # Var(avg) = (1/n^2) * sum of all elements in the sub-covariance matrix
+        n_post = len(post_periods)
+        sub_vcov = vcov[np.ix_(effect_indices, effect_indices)]
+        avg_var = np.sum(sub_vcov) / (n_post ** 2)
+        avg_se = np.sqrt(avg_var)
+
+        avg_t_stat = avg_att / avg_se if avg_se > 0 else 0.0
+        avg_p_value = compute_p_value(avg_t_stat, df=df)
+        avg_conf_int = compute_confidence_interval(avg_att, avg_se, self.alpha, df=df)
+
+        # Count observations
+        n_treated = int(np.sum(d))
+        n_control = int(np.sum(1 - d))
+
+        # Create coefficient dictionary
+        coef_dict = {name: coef for name, coef in zip(var_names, coefficients)}
+
+        # Store results
+        self.results_ = MultiPeriodDiDResults(
+            period_effects=period_effects,
+            avg_att=avg_att,
+            avg_se=avg_se,
+            avg_t_stat=avg_t_stat,
+            avg_p_value=avg_p_value,
+            avg_conf_int=avg_conf_int,
+            n_obs=len(y),
+            n_treated=n_treated,
+            n_control=n_control,
+            pre_periods=pre_periods,
+            post_periods=post_periods,
+            alpha=self.alpha,
+            coefficients=coef_dict,
+            vcov=vcov,
+            residuals=residuals,
+            fitted_values=fitted,
+            r_squared=r_squared,
+        )
+
+        self._coefficients = coefficients
+        self._vcov = vcov
+        self.is_fitted_ = True
+
+        return self.results_
+
+    def summary(self) -> str:
+        """
+        Get summary of estimation results.
+
+        Returns
+        -------
+        str
+            Formatted summary.
+        """
+        if not self.is_fitted_:
+            raise RuntimeError("Model must be fitted before calling summary()")
+        return self.results_.summary()

diff_diff/results.py

@@ -168,3 +168,296 @@ class DiDResults:
         elif self.p_value < 0.1:
             return "."
         return ""
+
+
+def _get_significance_stars(p_value: float) -> str:
+    """Return significance stars based on p-value."""
+    if p_value < 0.001:
+        return "***"
+    elif p_value < 0.01:
+        return "**"
+    elif p_value < 0.05:
+        return "*"
+    elif p_value < 0.1:
+        return "."
+    return ""
+
+
+@dataclass
+class PeriodEffect:
+    """
+    Treatment effect for a single time period.
+
+    Attributes
+    ----------
+    period : any
+        The time period identifier.
+    effect : float
+        The treatment effect estimate for this period.
+    se : float
+        Standard error of the effect estimate.
+    t_stat : float
+        T-statistic for the effect estimate.
+    p_value : float
+        P-value for the null hypothesis that effect = 0.
+    conf_int : tuple[float, float]
+        Confidence interval for the effect.
+    """
+
+    period: any
+    effect: float
+    se: float
+    t_stat: float
+    p_value: float
+    conf_int: tuple
+
+    def __repr__(self) -> str:
+        """Concise string representation."""
+        sig = _get_significance_stars(self.p_value)
+        return (
+            f"PeriodEffect(period={self.period}, effect={self.effect:.4f}{sig}, "
+            f"SE={self.se:.4f}, p={self.p_value:.4f})"
+        )
+
+    @property
+    def is_significant(self) -> bool:
+        """Check if the effect is statistically significant at 0.05 level."""
+        return bool(self.p_value < 0.05)
+
+    @property
+    def significance_stars(self) -> str:
+        """Return significance stars based on p-value."""
+        return _get_significance_stars(self.p_value)
+
+
+@dataclass
+class MultiPeriodDiDResults:
+    """
+    Results from a Multi-Period Difference-in-Differences estimation.
+
+    Provides access to period-specific treatment effects as well as
+    an aggregate average treatment effect.
+
+    Attributes
+    ----------
+    period_effects : dict[any, PeriodEffect]
+        Dictionary mapping period identifiers to their PeriodEffect objects.
+    avg_att : float
+        Average Treatment effect on the Treated across all post-periods.
+    avg_se : float
+        Standard error of the average ATT.
+    avg_t_stat : float
+        T-statistic for the average ATT.
+    avg_p_value : float
+        P-value for the null hypothesis that average ATT = 0.
+    avg_conf_int : tuple[float, float]
+        Confidence interval for the average ATT.
+    n_obs : int
+        Number of observations used in estimation.
+    n_treated : int
+        Number of treated observations.
+    n_control : int
+        Number of control observations.
+    pre_periods : list
+        List of pre-treatment period identifiers.
+    post_periods : list
+        List of post-treatment period identifiers.
+    """
+
+    period_effects: dict
+    avg_att: float
+    avg_se: float
+    avg_t_stat: float
+    avg_p_value: float
+    avg_conf_int: tuple
+    n_obs: int
+    n_treated: int
+    n_control: int
+    pre_periods: list
+    post_periods: list
+    alpha: float = 0.05
+    coefficients: Optional[dict] = field(default=None)
+    vcov: Optional[np.ndarray] = field(default=None)
+    residuals: Optional[np.ndarray] = field(default=None)
+    fitted_values: Optional[np.ndarray] = field(default=None)
+    r_squared: Optional[float] = field(default=None)
+
+    def __repr__(self) -> str:
+        """Concise string representation."""
+        sig = _get_significance_stars(self.avg_p_value)
+        return (
+            f"MultiPeriodDiDResults(avg_ATT={self.avg_att:.4f}{sig}, "
+            f"SE={self.avg_se:.4f}, "
+            f"n_post_periods={len(self.post_periods)})"
+        )
+
+    def summary(self, alpha: Optional[float] = None) -> str:
+        """
+        Generate a formatted summary of the estimation results.
+
+        Parameters
+        ----------
+        alpha : float, optional
+            Significance level for confidence intervals. Defaults to the
+            alpha used during estimation.
+
+        Returns
+        -------
+        str
+            Formatted summary table.
+        """
+        alpha = alpha or self.alpha
+        conf_level = int((1 - alpha) * 100)
+
+        lines = [
+            "=" * 80,
+            "Multi-Period Difference-in-Differences Estimation Results".center(80),
+            "=" * 80,
+            "",
+            f"{'Observations:':<25} {self.n_obs:>10}",
+            f"{'Treated observations:':<25} {self.n_treated:>10}",
+            f"{'Control observations:':<25} {self.n_control:>10}",
+            f"{'Pre-treatment periods:':<25} {len(self.pre_periods):>10}",
+            f"{'Post-treatment periods:':<25} {len(self.post_periods):>10}",
+        ]
+
+        if self.r_squared is not None:
+            lines.append(f"{'R-squared:':<25} {self.r_squared:>10.4f}")
+
+        # Period-specific effects
+        lines.extend([
+            "",
+            "-" * 80,
+            "Period-Specific Treatment Effects".center(80),
+            "-" * 80,
+            f"{'Period':<15} {'Estimate':>12} {'Std. Err.':>12} {'t-stat':>10} {'P>|t|':>10} {'Sig.':>6}",
+            "-" * 80,
+        ])
+
+        for period in self.post_periods:
+            pe = self.period_effects[period]
+            stars = pe.significance_stars
+            lines.append(
+                f"{str(period):<15} {pe.effect:>12.4f} {pe.se:>12.4f} "
+                f"{pe.t_stat:>10.3f} {pe.p_value:>10.4f} {stars:>6}"
+            )
+
+        # Average effect
+        lines.extend([
+            "-" * 80,
+            "",
+            "-" * 80,
+            "Average Treatment Effect (across post-periods)".center(80),
+            "-" * 80,
+            f"{'Parameter':<15} {'Estimate':>12} {'Std. Err.':>12} {'t-stat':>10} {'P>|t|':>10}",
+            "-" * 80,
+            f"{'Avg ATT':<15} {self.avg_att:>12.4f} {self.avg_se:>12.4f} "
+            f"{self.avg_t_stat:>10.3f} {self.avg_p_value:>10.4f}",
+            "-" * 80,
+            "",
+            f"{conf_level}% Confidence Interval: [{self.avg_conf_int[0]:.4f}, {self.avg_conf_int[1]:.4f}]",
+        ])
+
+        # Add significance codes
+        lines.extend([
+            "",
+            "Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1",
+            "=" * 80,
+        ])
+
+        return "\n".join(lines)
+
+    def print_summary(self, alpha: Optional[float] = None) -> None:
+        """Print the summary to stdout."""
+        print(self.summary(alpha))
+
+    def get_effect(self, period) -> PeriodEffect:
+        """
+        Get the treatment effect for a specific period.
+
+        Parameters
+        ----------
+        period : any
+            The period identifier.
+
+        Returns
+        -------
+        PeriodEffect
+            The treatment effect for the specified period.
+
+        Raises
+        ------
+        KeyError
+            If the period is not found in post-treatment periods.
+        """
+        if period not in self.period_effects:
+            raise KeyError(
+                f"Period '{period}' not found. "
+                f"Available post-periods: {list(self.period_effects.keys())}"
+            )
+        return self.period_effects[period]
+
+    def to_dict(self) -> dict:
+        """
+        Convert results to a dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary containing all estimation results.
+        """
+        result = {
+            "avg_att": self.avg_att,
+            "avg_se": self.avg_se,
+            "avg_t_stat": self.avg_t_stat,
+            "avg_p_value": self.avg_p_value,
+            "avg_conf_int_lower": self.avg_conf_int[0],
+            "avg_conf_int_upper": self.avg_conf_int[1],
+            "n_obs": self.n_obs,
+            "n_treated": self.n_treated,
+            "n_control": self.n_control,
+            "n_pre_periods": len(self.pre_periods),
+            "n_post_periods": len(self.post_periods),
+            "r_squared": self.r_squared,
+        }
+
+        # Add period-specific effects
+        for period, pe in self.period_effects.items():
+            result[f"effect_period_{period}"] = pe.effect
+            result[f"se_period_{period}"] = pe.se
+            result[f"pval_period_{period}"] = pe.p_value
+
+        return result
+
+    def to_dataframe(self) -> pd.DataFrame:
+        """
+        Convert period-specific effects to a pandas DataFrame.
+
+        Returns
+        -------
+        pd.DataFrame
+            DataFrame with one row per post-treatment period.
+        """
+        rows = []
+        for period, pe in self.period_effects.items():
+            rows.append({
+                "period": period,
+                "effect": pe.effect,
+                "se": pe.se,
+                "t_stat": pe.t_stat,
+                "p_value": pe.p_value,
+                "conf_int_lower": pe.conf_int[0],
+                "conf_int_upper": pe.conf_int[1],
+                "is_significant": pe.is_significant,
+            })
+        return pd.DataFrame(rows)
+
+    @property
+    def is_significant(self) -> bool:
+        """Check if the average ATT is statistically significant at the alpha level."""
+        return bool(self.avg_p_value < self.alpha)
+
+    @property
+    def significance_stars(self) -> str:
+        """Return significance stars for the average ATT based on p-value."""
+        return _get_significance_stars(self.avg_p_value)

diff_diff/utils.py

@@ -218,13 +218,18 @@ def check_parallel_trends(
         mean_t = np.mean(time_norm)
         mean_y = np.mean(outcome_values)
 
-        slope = np.sum((time_norm - mean_t) * (outcome_values - mean_y)) / np.sum((time_norm - mean_t) ** 2)
+        # Check for zero variance in time (all same time period)
+        time_var = np.sum((time_norm - mean_t) ** 2)
+        if time_var == 0:
+            return np.nan, np.nan
+
+        slope = np.sum((time_norm - mean_t) * (outcome_values - mean_y)) / time_var
 
         # Compute standard error of slope
         y_hat = mean_y + slope * (time_norm - mean_t)
         residuals = outcome_values - y_hat
         mse = np.sum(residuals ** 2) / (n - 2)
-        se_slope = np.sqrt(mse / np.sum((time_norm - mean_t) ** 2))
+        se_slope = np.sqrt(mse / time_var)
 
         return slope, se_slope
 
@@ -258,7 +263,8 @@ def check_parallel_trends_robust(
     unit: str = None,
     pre_periods: list = None,
     n_permutations: int = 1000,
-    seed: int = None
+    seed: int = None,
+    wasserstein_threshold: float = 0.2
 ) -> dict:
     """
     Perform robust parallel trends testing using distributional comparisons.
@@ -286,6 +292,9 @@ def check_parallel_trends_robust(
         Number of permutations for computing p-value.
     seed : int, optional
         Random seed for reproducibility.
+    wasserstein_threshold : float, default=0.2
+        Threshold for normalized Wasserstein distance. Values below this
+        threshold (combined with p > 0.05) suggest parallel trends are plausible.
 
     Returns
     -------
@@ -321,8 +330,8 @@ def check_parallel_trends_robust(
     of pre-treatment changes are similar, supporting the parallel trends
     assumption.
     """
-    if seed is not None:
-        np.random.seed(seed)
+    # Use local RNG to avoid affecting global random state
+    rng = np.random.default_rng(seed)
 
     # Identify pre-treatment periods
     if pre_periods is None:
@@ -361,7 +370,7 @@ def check_parallel_trends_robust(
 
     permuted_distances = np.zeros(n_permutations)
     for i in range(n_permutations):
-        perm_idx = np.random.permutation(n_total)
+        perm_idx = rng.permutation(n_total)
         perm_treated = all_changes[perm_idx[:n_treated]]
         perm_control = all_changes[perm_idx[n_treated:]]
         permuted_distances[i] = stats.wasserstein_distance(perm_treated, perm_control)
@@ -383,10 +392,10 @@ def check_parallel_trends_robust(
     wasserstein_normalized = wasserstein_dist / pooled_std if pooled_std > 0 else np.nan
 
     # Assessment: parallel trends plausible if p-value > 0.05
-    # and normalized Wasserstein is small (< 0.2 as rule of thumb)
+    # and normalized Wasserstein is small (below threshold)
     plausible = bool(
         wasserstein_p > 0.05 and
-        (wasserstein_normalized < 0.2 if not np.isnan(wasserstein_normalized) else True)
+        (wasserstein_normalized < wasserstein_threshold if not np.isnan(wasserstein_normalized) else True)
     )
 
     return {
@@ -523,23 +532,64 @@ def equivalence_test_trends(
         pre_data, outcome, time, treatment_group, unit
     )
 
+    # Need at least 2 observations per group to compute variance
+    # and at least 3 total for meaningful df calculation
     if len(treated_changes) < 2 or len(control_changes) < 2:
         return {
             "mean_difference": np.nan,
+            "se_difference": np.nan,
             "equivalence_margin": np.nan,
+            "lower_t_stat": np.nan,
+            "upper_t_stat": np.nan,
             "lower_p_value": np.nan,
             "upper_p_value": np.nan,
             "tost_p_value": np.nan,
+            "degrees_of_freedom": np.nan,
             "equivalent": None,
-            "error": "Insufficient data",
+            "error": "Insufficient data (need at least 2 observations per group)",
         }
 
     # Compute statistics
+    var_t = np.var(treated_changes, ddof=1)
+    var_c = np.var(control_changes, ddof=1)
+    n_t = len(treated_changes)
+    n_c = len(control_changes)
+
     mean_diff = np.mean(treated_changes) - np.mean(control_changes)
-    se_diff = np.sqrt(
-        np.var(treated_changes, ddof=1) / len(treated_changes) +
-        np.var(control_changes, ddof=1) / len(control_changes)
-    )
+
+    # Handle zero variance case
+    if var_t == 0 and var_c == 0:
+        return {
+            "mean_difference": mean_diff,
+            "se_difference": 0.0,
+            "equivalence_margin": np.nan,
+            "lower_t_stat": np.nan,
+            "upper_t_stat": np.nan,
+            "lower_p_value": np.nan,
+            "upper_p_value": np.nan,
+            "tost_p_value": np.nan,
+            "degrees_of_freedom": np.nan,
+            "equivalent": None,
+            "error": "Zero variance in both groups - cannot perform t-test",
+        }
+
+    se_diff = np.sqrt(var_t / n_t + var_c / n_c)
+
+    # Handle zero SE case (cannot divide by zero in t-stat calculation)
+    if se_diff == 0:
+        return {
+            "mean_difference": mean_diff,
+            "se_difference": 0.0,
+            "equivalence_margin": np.nan,
+            "lower_t_stat": np.nan,
+            "upper_t_stat": np.nan,
+            "lower_p_value": np.nan,
+            "upper_p_value": np.nan,
+            "tost_p_value": np.nan,
+            "degrees_of_freedom": np.nan,
+            "equivalent": None,
+            "error": "Zero standard error - cannot perform t-test",
+        }
 
     # Set equivalence margin if not provided
     if equivalence_margin is None:
@@ -547,13 +597,17 @@ def equivalence_test_trends(
         equivalence_margin = 0.5 * np.std(pooled_changes, ddof=1)
 
     # Degrees of freedom (Welch-Satterthwaite approximation)
-    var_t = np.var(treated_changes, ddof=1)
-    var_c = np.var(control_changes, ddof=1)
-    n_t = len(treated_changes)
-    n_c = len(control_changes)
-
-    df = ((var_t/n_t + var_c/n_c)**2 /
-          ((var_t/n_t)**2/(n_t-1) + (var_c/n_c)**2/(n_c-1)))
+    # Guard against division by zero when one group has zero variance
+    numerator = (var_t/n_t + var_c/n_c)**2
+    denom_t = (var_t/n_t)**2/(n_t-1) if var_t > 0 else 0
+    denom_c = (var_c/n_c)**2/(n_c-1) if var_c > 0 else 0
+    denominator = denom_t + denom_c
+
+    if denominator == 0:
+        # Fall back to minimum of n_t-1 and n_c-1 when one variance is zero
+        df = min(n_t - 1, n_c - 1)
+    else:
+        df = numerator / denominator
 
     # TOST: Two one-sided tests
     # Test 1: H0: diff <= -margin vs H1: diff > -margin

{diff_diff-0.1.0.dist-info → diff_diff-0.2.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 0.1.0
+Version: 0.2.0
 Summary: A library for Difference-in-Differences causal inference analysis
 Author: diff-diff contributors
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/igerber/diff-diff
 Project-URL: Documentation, https://github.com/igerber/diff-diff#readme
 Project-URL: Repository, https://github.com/igerber/diff-diff
@@ -103,6 +103,7 @@ Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1
 - **Multiple interfaces**: Column names or R-style formulas
 - **Robust inference**: Heteroskedasticity-robust (HC1) and cluster-robust standard errors
 - **Panel data support**: Two-way fixed effects estimator for panel designs
+- **Multi-period analysis**: Event-study style DiD with period-specific treatment effects
 
 ## Usage
 
@@ -224,6 +225,66 @@ results = twfe.fit(
 )
 ```
 
+### Multi-Period DiD (Event Study)
+
+For settings with multiple pre- and post-treatment periods:
+
+```python
+from diff_diff import MultiPeriodDiD
+
+# Fit with multiple time periods
+did = MultiPeriodDiD()
+results = did.fit(
+    panel_data,
+    outcome='sales',
+    treatment='treated',
+    time='period',
+    post_periods=[3, 4, 5],      # Periods 3-5 are post-treatment
+    reference_period=0           # Reference period for comparison
+)
+
+# View period-specific treatment effects
+for period, effect in results.period_effects.items():
+    print(f"Period {period}: {effect.effect:.3f} (SE: {effect.se:.3f})")
+
+# View average treatment effect across post-periods
+print(f"Average ATT: {results.avg_att:.3f}")
+print(f"Average SE: {results.avg_se:.3f}")
+
+# Full summary with all period effects
+results.print_summary()
+```
+
+Output:
+```
+================================================================================
+            Multi-Period Difference-in-Differences Estimation Results
+================================================================================
+
+Observations:                      600
+Pre-treatment periods:             3
+Post-treatment periods:            3
+
+--------------------------------------------------------------------------------
+Average Treatment Effect
+--------------------------------------------------------------------------------
+Average ATT       5.2000       0.8234      6.315      0.0000
+--------------------------------------------------------------------------------
+95% Confidence Interval: [3.5862, 6.8138]
+
+Period-Specific Effects:
+--------------------------------------------------------------------------------
+Period            Effect     Std. Err.     t-stat      P>|t|
+--------------------------------------------------------------------------------
+3                 4.5000       0.9512      4.731      0.0000***
+4                 5.2000       0.8876      5.858      0.0000***
+5                 5.9000       0.9123      6.468      0.0000***
+--------------------------------------------------------------------------------
+
+Signif. codes: '***' 0.001, '**' 0.01, '*' 0.05, '.' 0.1
+================================================================================
+```
+
 ## Working with Results
 
 ### Export Results
@@ -395,6 +456,71 @@ DifferenceInDifferences(
 | `to_dict()` | Convert to dictionary |
 | `to_dataframe()` | Convert to pandas DataFrame |
 
+### MultiPeriodDiD
+
+```python
+MultiPeriodDiD(
+    robust=True,      # Use HC1 robust standard errors
+    cluster=None,     # Column for cluster-robust SEs
+    alpha=0.05        # Significance level for CIs
+)
+```
+
+**fit() Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `data` | DataFrame | Input data |
+| `outcome` | str | Outcome variable column name |
+| `treatment` | str | Treatment indicator column (0/1) |
+| `time` | str | Time period column (multiple values) |
+| `post_periods` | list | List of post-treatment period values |
+| `covariates` | list | Linear control variables |
+| `fixed_effects` | list | Categorical FE columns (creates dummies) |
+| `absorb` | list | High-dimensional FE (within-transformation) |
+| `reference_period` | any | Omitted period for time dummies |
+
+### MultiPeriodDiDResults
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `period_effects` | Dict mapping periods to PeriodEffect objects |
+| `avg_att` | Average ATT across post-treatment periods |
+| `avg_se` | Standard error of average ATT |
+| `avg_t_stat` | T-statistic for average ATT |
+| `avg_p_value` | P-value for average ATT |
+| `avg_conf_int` | Confidence interval for average ATT |
+| `n_obs` | Number of observations |
+| `pre_periods` | List of pre-treatment periods |
+| `post_periods` | List of post-treatment periods |
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `get_effect(period)` | Get PeriodEffect for specific period |
+| `summary(alpha)` | Get formatted summary string |
+| `print_summary(alpha)` | Print summary to stdout |
+| `to_dict()` | Convert to dictionary |
+| `to_dataframe()` | Convert to pandas DataFrame |
+
+### PeriodEffect
+
+**Attributes:**
+
+| Attribute | Description |
+|-----------|-------------|
+| `period` | Time period identifier |
+| `effect` | Treatment effect estimate |
+| `se` | Standard error |
+| `t_stat` | T-statistic |
+| `p_value` | P-value |
+| `conf_int` | Confidence interval |
+| `is_significant` | Boolean for significance at 0.05 |
+| `significance_stars` | String of significance stars |
+
 ## Requirements
 
 - Python >= 3.9

diff_diff-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+diff_diff/__init__.py,sha256=Xs0N2vloLpWcfVdNrzNHVyywGWeLyYXvEGqC0IbDKbI,495
+diff_diff/estimators.py,sha256=M-HwruLO3JK0EEpDOfc3BtUe3WBXc4VNSbZEvnNkxMQ,34774
+diff_diff/results.py,sha256=bBa-exmj81SZRZsHGBwkXF46-dGUEi6Oa8dpZhLVmpc,14113
+diff_diff/utils.py,sha256=M8k92rxZbLZaRabaJlk4i21pTTyvukStn76v_cK8kEQ,20281
+diff_diff-0.2.0.dist-info/METADATA,sha256=8LHL1vsG4TvQYg-I_of1TRngFQ0iGue8uqkieetN4sc,15389
+diff_diff-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+diff_diff-0.2.0.dist-info/top_level.txt,sha256=-7mAFgjEQIA2okDLHlh5pDwBQXnsO1Z85qvtHjZILoQ,10
+diff_diff-0.2.0.dist-info/RECORD,,

diff_diff-0.1.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-diff_diff/__init__.py,sha256=Jx8koPCUIMTcs8-Q-iuuYfXRztp-ccfrujGPYWoEHj0,360
-diff_diff/estimators.py,sha256=9yylm11pVjyQCmx2RmJYWYQxLETfBAu2-IYNI-xlyZg,21991
-diff_diff/results.py,sha256=PortPWdfZh25zVcSYSFnJ5maeredP6D4sNLIYd2ntzc,4961
-diff_diff/utils.py,sha256=LLzBPo6xmK7ZRkMGFEmlRSLq-VW1gxP-FzzG8zvAsiw,18200
-diff_diff-0.1.0.dist-info/METADATA,sha256=jw5DWL1DczDQcvmQHUdO_xyV2xZlKJkk6caP8iMmXPs,10974
-diff_diff-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-diff_diff-0.1.0.dist-info/top_level.txt,sha256=-7mAFgjEQIA2okDLHlh5pDwBQXnsO1Z85qvtHjZILoQ,10
-diff_diff-0.1.0.dist-info/RECORD,,