diff-diff 1.3.1__tar.gz → 2.0.0__tar.gz

{diff_diff-1.3.1 → diff_diff-2.0.0}/PKG-INFO

@@ -1,14 +1,6 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 1.3.1
-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://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
+Version: 2.0.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
@@ -18,20 +10,28 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
 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-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: sphinx>=6.0 ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=1.0 ; extra == 'docs'
 Provides-Extra: dev
-Requires-Dist: pytest>=7.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"
 Provides-Extra: docs
-Requires-Dist: sphinx>=6.0; extra == "docs"
-Requires-Dist: sphinx-rtd-theme>=1.0; 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
 
@@ -2253,3 +2253,4 @@ The `HonestDiD` module implements sensitivity analysis methods for relaxing the
 ## License
 
 MIT License
+

{diff_diff-1.3.1 → diff_diff-2.0.0}/diff_diff/__init__.py

@@ -5,6 +5,16 @@ This library provides sklearn-like estimators for causal inference
 using the difference-in-differences methodology.
 """
 
+# Import backend detection from dedicated module (avoids circular imports)
+from diff_diff._backend import (
+    HAS_RUST_BACKEND,
+    _rust_bootstrap_weights,
+    _rust_compute_robust_vcov,
+    _rust_project_simplex,
+    _rust_solve_ols,
+    _rust_synthetic_weights,
+)
+
 from diff_diff.bacon import (
     BaconDecomposition,
     BaconDecompositionResults,
@@ -103,7 +113,7 @@ from diff_diff.visualization import (
     plot_sensitivity,
 )
 
-__version__ = "1.3.1"
+__version__ = "2.0.0"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",
@@ -187,4 +197,6 @@ __all__ = [
     "compute_pretrends_power",
     "compute_mdv",
     "plot_pretrends_power",
+    # Rust backend
+    "HAS_RUST_BACKEND",
 ]

diff_diff-2.0.0/diff_diff/_backend.py

@@ -0,0 +1,64 @@
+"""
+Backend detection and configuration for diff-diff.
+
+This module handles:
+1. Detection of optional Rust backend
+2. Environment variable configuration (DIFF_DIFF_BACKEND)
+3. Exports HAS_RUST_BACKEND and Rust function references
+
+Other modules should import from here to avoid circular imports with __init__.py.
+"""
+
+import os
+
+# Check for backend override via environment variable
+# DIFF_DIFF_BACKEND can be: 'auto' (default), 'python', or 'rust'
+_backend_env = os.environ.get('DIFF_DIFF_BACKEND', 'auto').lower()
+
+# Try to import Rust backend for accelerated operations
+try:
+    from diff_diff._rust_backend import (
+        generate_bootstrap_weights_batch as _rust_bootstrap_weights,
+        compute_synthetic_weights as _rust_synthetic_weights,
+        project_simplex as _rust_project_simplex,
+        solve_ols as _rust_solve_ols,
+        compute_robust_vcov as _rust_compute_robust_vcov,
+    )
+    _rust_available = True
+except ImportError:
+    _rust_available = False
+    _rust_bootstrap_weights = None
+    _rust_synthetic_weights = None
+    _rust_project_simplex = None
+    _rust_solve_ols = None
+    _rust_compute_robust_vcov = None
+
+# Determine final backend based on environment variable and availability
+if _backend_env == 'python':
+    # Force pure Python mode - disable Rust even if available
+    HAS_RUST_BACKEND = False
+    _rust_bootstrap_weights = None
+    _rust_synthetic_weights = None
+    _rust_project_simplex = None
+    _rust_solve_ols = None
+    _rust_compute_robust_vcov = None
+elif _backend_env == 'rust':
+    # Force Rust mode - fail if not available
+    if not _rust_available:
+        raise ImportError(
+            "DIFF_DIFF_BACKEND=rust but Rust backend is not available. "
+            "Install with: pip install diff-diff[rust]"
+        )
+    HAS_RUST_BACKEND = True
+else:
+    # Auto mode - use Rust if available
+    HAS_RUST_BACKEND = _rust_available
+
+__all__ = [
+    'HAS_RUST_BACKEND',
+    '_rust_bootstrap_weights',
+    '_rust_synthetic_weights',
+    '_rust_project_simplex',
+    '_rust_solve_ols',
+    '_rust_compute_robust_vcov',
+]

{diff_diff-1.3.1 → diff_diff-2.0.0}/diff_diff/estimators.py

@@ -17,12 +17,12 @@ from typing import Any, Dict, List, Optional, Tuple
 import numpy as np
 import pandas as pd
 
+from diff_diff.linalg import compute_r_squared, compute_robust_vcov, solve_ols
 from diff_diff.results import DiDResults, MultiPeriodDiDResults, PeriodEffect
 from diff_diff.utils import (
     WildBootstrapResults,
     compute_confidence_interval,
     compute_p_value,
-    compute_robust_se,
     validate_binary,
     wild_bootstrap_se,
 )
@@ -261,8 +261,11 @@ class DifferenceInDifferences:
                     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)
+        # Fit OLS using unified backend
+        coefficients, residuals, fitted, vcov = solve_ols(
+            X, y, return_fitted=True, return_vcov=False
+        )
+        r_squared = compute_r_squared(y, residuals)
 
         # Extract ATT (coefficient on interaction term)
         att_idx = 3  # Index of interaction term
@@ -285,13 +288,13 @@ class DifferenceInDifferences:
             )
         elif self.cluster is not None:
             cluster_ids = data[self.cluster].values
-            vcov = compute_robust_se(X, residuals, cluster_ids)
+            vcov = compute_robust_vcov(X, residuals, cluster_ids)
             se = np.sqrt(vcov[att_idx, att_idx])
             t_stat = att / se
             p_value = compute_p_value(t_stat, df=df)
             conf_int = compute_confidence_interval(att, se, self.alpha, df=df)
         elif self.robust:
-            vcov = compute_robust_se(X, residuals)
+            vcov = compute_robust_vcov(X, residuals)
             se = np.sqrt(vcov[att_idx, att_idx])
             t_stat = att / se
             p_value = compute_p_value(t_stat, df=df)
@@ -300,7 +303,7 @@ class DifferenceInDifferences:
             # Classical OLS standard errors
             n = len(y)
             k = X.shape[1]
-            mse = np.sum(residuals ** 2) / (n - k)
+            mse = np.sum(residuals**2) / (n - k)
             # Use solve() instead of inv() for numerical stability
             # solve(A, B) computes X where AX=B, so this yields (X'X)^{-1} * mse
             vcov = np.linalg.solve(X.T @ X, mse * np.eye(k))
@@ -352,10 +355,15 @@ class DifferenceInDifferences:
 
         return self.results_
 
-    def _fit_ols(self, X: np.ndarray, y: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:
+    def _fit_ols(
+        self, X: np.ndarray, y: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:
         """
         Fit OLS regression.
 
+        This method is kept for backwards compatibility. Internally uses the
+        unified solve_ols from diff_diff.linalg for optimized computation.
+
         Parameters
         ----------
         X : np.ndarray
@@ -367,32 +375,12 @@ 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]
-
-        # Compute fitted values and residuals
-        fitted = X @ coefficients
-        residuals = y - fitted
-
-        # Compute R-squared
-        ss_res = np.sum(residuals ** 2)
-        ss_tot = np.sum((y - np.mean(y)) ** 2)
-        r_squared = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0.0
+        # Use unified OLS backend
+        coefficients, residuals, fitted, _ = solve_ols(
+            X, y, return_fitted=True, return_vcov=False
+        )
+        r_squared = compute_r_squared(y, residuals)
 
         return coefficients, residuals, fitted, r_squared
 
@@ -442,7 +430,7 @@ class DifferenceInDifferences:
         t_stat = bootstrap_results.t_stat_original
 
         # Also compute vcov for storage (using cluster-robust for consistency)
-        vcov = compute_robust_se(X, residuals, cluster_ids)
+        vcov = compute_robust_vcov(X, residuals, cluster_ids)
 
         return se, p_value, conf_int, t_stat, vcov, bootstrap_results
 
@@ -889,8 +877,11 @@ class MultiPeriodDiD(DifferenceInDifferences):
                     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)
+        # Fit OLS using unified backend
+        coefficients, residuals, fitted, _ = solve_ols(
+            X, y, return_fitted=True, return_vcov=False
+        )
+        r_squared = compute_r_squared(y, residuals)
 
         # Degrees of freedom
         df = len(y) - X.shape[1] - n_absorbed_effects
@@ -900,13 +891,13 @@ class MultiPeriodDiD(DifferenceInDifferences):
         # For now, we use analytical inference even if inference="wild_bootstrap"
         if self.cluster is not None:
             cluster_ids = data[self.cluster].values
-            vcov = compute_robust_se(X, residuals, cluster_ids)
+            vcov = compute_robust_vcov(X, residuals, cluster_ids)
         elif self.robust:
-            vcov = compute_robust_se(X, residuals)
+            vcov = compute_robust_vcov(X, residuals)
         else:
             n = len(y)
             k = X.shape[1]
-            mse = np.sum(residuals ** 2) / (n - k)
+            mse = np.sum(residuals**2) / (n - k)
             # Use solve() instead of inv() for numerical stability
             # solve(A, B) computes X where AX=B, so this yields (X'X)^{-1} * mse
             vcov = np.linalg.solve(X.T @ X, mse * np.eye(k))