Centralize deprecated design-alias boilerplate and fix internal callers

Move _build_design_dataset helper and __getattr__ deprecation forwarding
into BaseExperiment, replacing per-class @Property blocks with a
declarative _deprecated_design_aliases dict. Fix convex_hull.py and
maketables_adapters.py to use the new API directly. Add parametrized
backward-compatibility tests covering all deprecated aliases.

Made-with: Cursor

Author: drbenvincent

causalpy/checks/convex_hull.py

@@ -50,8 +50,8 @@ def run(
     ) -> CheckResult:
         """Run the convex hull violation check on pre-treatment data."""
         sc = experiment
-        datapre_control = sc.datapre_control  # type: ignore[attr-defined]
-        datapre_treated = sc.datapre_treated  # type: ignore[attr-defined]
+        datapre_control = sc.pre_design["control"]  # type: ignore[attr-defined]
+        datapre_treated = sc.pre_design["treated"]  # type: ignore[attr-defined]
 
         all_results = []
         total_violations = 0

causalpy/experiments/base.py

@@ -18,13 +18,16 @@
 from __future__ import annotations
 
 import contextlib
+import warnings
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Literal
 
 import arviz as az
 import matplotlib.pyplot as plt
+import numpy as np
 import pandas as pd
+import xarray as xr
 from sklearn.base import RegressorMixin
 
 from causalpy.maketables_adapters import get_maketables_adapter
@@ -114,6 +117,67 @@ class BaseExperiment(ABC):
 
     _default_model_class: type[PyMCModel] | None = None
 
+    _deprecated_design_aliases: dict[str, tuple[str, str]] = {}
+    """Mapping of ``old_attr -> (dataset_attr, key)`` for deprecated design
+    matrix accessors.  Subclasses populate this so that
+    ``__getattr__`` can forward accesses with a deprecation warning."""
+
+    def __getattr__(self, name: str) -> Any:
+        aliases = type(self)._deprecated_design_aliases
+        if name in aliases:
+            dataset_attr, key = aliases[name]
+            warnings.warn(
+                f"{name} is deprecated, use {dataset_attr}['{key}']",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return getattr(self, dataset_attr)[key]
+        raise AttributeError(
+            f"'{type(self).__name__}' object has no attribute '{name}'"
+        )
+
+    @staticmethod
+    def _build_design_dataset(
+        X_raw: np.ndarray,
+        y_raw: np.ndarray,
+        *,
+        obs_ind: np.ndarray | pd.Index,
+        coeffs: list[str],
+        treated_units: list[str] | None = None,
+    ) -> xr.Dataset:
+        """Build a standard ``xr.Dataset`` from raw design matrices.
+
+        Parameters
+        ----------
+        X_raw : np.ndarray
+            Predictor matrix, shape ``(n_obs, n_coeffs)``.
+        y_raw : np.ndarray
+            Outcome matrix, shape ``(n_obs, n_units)``.
+        obs_ind : array-like
+            Observation index coordinates.
+        coeffs : list[str]
+            Coefficient / column names for ``X_raw``.
+        treated_units : list[str], optional
+            Names for the treated-unit dimension of ``y_raw``.
+            Defaults to ``["unit_0"]``.
+        """
+        if treated_units is None:
+            treated_units = ["unit_0"]
+        return xr.Dataset(
+            {
+                "X": xr.DataArray(
+                    X_raw,
+                    dims=["obs_ind", "coeffs"],
+                    coords={"obs_ind": obs_ind, "coeffs": coeffs},
+                ),
+                "y": xr.DataArray(
+                    y_raw,
+                    dims=["obs_ind", "treated_units"],
+                    coords={"obs_ind": obs_ind, "treated_units": treated_units},
+                ),
+            }
+        )
+
     def __init__(self, model: PyMCModel | RegressorMixin | None = None) -> None:
         # Ensure we've made any provided Scikit Learn model (as identified as being type
         # RegressorMixin) compatible with CausalPy by appending our custom methods.

causalpy/experiments/diff_in_diff.py

@@ -15,7 +15,6 @@
 Difference in differences
 """
 
-import warnings
 from typing import Any, Literal
 
 import arviz as az
@@ -98,6 +97,7 @@ class DifferenceInDifferences(BaseExperiment):
     supports_ols = True
     supports_bayes = True
     _default_model_class = LinearRegression
+    _deprecated_design_aliases = {"X": ("design", "X"), "y": ("design", "y")}
 
     def __init__(
         self,
@@ -136,38 +136,14 @@ def _build_design_matrices(self) -> None:
     def _prepare_data(self) -> None:
         """Bundle design matrices into an ``xr.Dataset``."""
         n = self._X_raw.shape[0]
-        self.design = xr.Dataset(
-            {
-                "X": xr.DataArray(
-                    self._X_raw,
-                    dims=["obs_ind", "coeffs"],
-                    coords={"obs_ind": np.arange(n), "coeffs": self.labels},
-                ),
-                "y": xr.DataArray(
-                    self._y_raw,
-                    dims=["obs_ind", "treated_units"],
-                    coords={"obs_ind": np.arange(n), "treated_units": ["unit_0"]},
-                ),
-            }
+        self.design = self._build_design_dataset(
+            self._X_raw,
+            self._y_raw,
+            obs_ind=np.arange(n),
+            coeffs=self.labels,
         )
         del self._X_raw, self._y_raw
 
-    @property
-    def X(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.design['X']`` instead."""
-        warnings.warn(
-            "X is deprecated, use design['X']", DeprecationWarning, stacklevel=2
-        )
-        return self.design["X"]
-
-    @property
-    def y(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.design['y']`` instead."""
-        warnings.warn(
-            "y is deprecated, use design['y']", DeprecationWarning, stacklevel=2
-        )
-        return self.design["y"]
-
     def algorithm(self) -> None:
         """Run the experiment algorithm: fit model, predict, and calculate causal impact."""
         X = self.design["X"]

causalpy/experiments/interrupted_time_series.py

@@ -15,7 +15,6 @@
 Interrupted Time Series Analysis
 """
 
-import warnings
 from typing import Any, Literal
 
 import arviz as az
@@ -129,6 +128,12 @@ class InterruptedTimeSeries(BaseExperiment):
     supports_ols = True
     supports_bayes = True
     _default_model_class = LinearRegression
+    _deprecated_design_aliases = {
+        "pre_X": ("pre_design", "X"),
+        "pre_y": ("pre_design", "y"),
+        "post_X": ("post_design", "X"),
+        "post_y": ("post_design", "y"),
+    }
 
     def __init__(
         self,
@@ -169,39 +174,17 @@ def _build_design_matrices(self) -> None:
 
     def _prepare_data(self) -> None:
         """Bundle design matrices into ``xr.Dataset`` objects for pre and post periods."""
-        self.pre_design = xr.Dataset(
-            {
-                "X": xr.DataArray(
-                    self._pre_X_raw,
-                    dims=["obs_ind", "coeffs"],
-                    coords={"obs_ind": self.datapre.index, "coeffs": self.labels},
-                ),
-                "y": xr.DataArray(
-                    self._pre_y_raw,
-                    dims=["obs_ind", "treated_units"],
-                    coords={
-                        "obs_ind": self.datapre.index,
-                        "treated_units": ["unit_0"],
-                    },
-                ),
-            }
+        self.pre_design = self._build_design_dataset(
+            self._pre_X_raw,
+            self._pre_y_raw,
+            obs_ind=self.datapre.index,
+            coeffs=self.labels,
         )
-        self.post_design = xr.Dataset(
-            {
-                "X": xr.DataArray(
-                    self._post_X_raw,
-                    dims=["obs_ind", "coeffs"],
-                    coords={"obs_ind": self.datapost.index, "coeffs": self.labels},
-                ),
-                "y": xr.DataArray(
-                    self._post_y_raw,
-                    dims=["obs_ind", "treated_units"],
-                    coords={
-                        "obs_ind": self.datapost.index,
-                        "treated_units": ["unit_0"],
-                    },
-                ),
-            }
+        self.post_design = self._build_design_dataset(
+            self._post_X_raw,
+            self._post_y_raw,
+            obs_ind=self.datapost.index,
+            coeffs=self.labels,
         )
         del self._pre_X_raw, self._pre_y_raw, self._post_X_raw, self._post_y_raw
 
@@ -320,46 +303,6 @@ def datapost(self) -> pd.DataFrame:
         """
         return self.data[self.data.index >= self.treatment_time]
 
-    @property
-    def pre_X(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.pre_design['X']`` instead."""
-        warnings.warn(
-            "pre_X is deprecated, use pre_design['X']",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.pre_design["X"]
-
-    @property
-    def pre_y(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.pre_design['y']`` instead."""
-        warnings.warn(
-            "pre_y is deprecated, use pre_design['y']",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.pre_design["y"]
-
-    @property
-    def post_X(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.post_design['X']`` instead."""
-        warnings.warn(
-            "post_X is deprecated, use post_design['X']",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.post_design["X"]
-
-    @property
-    def post_y(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.post_design['y']`` instead."""
-        warnings.warn(
-            "post_y is deprecated, use post_design['y']",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.post_design["y"]
-
     def _split_post_period(self) -> None:
         """Split post period into intervention and post-intervention periods.
 

causalpy/experiments/panel_regression.py

@@ -15,14 +15,12 @@
 Panel Regression with Fixed Effects
 """
 
-import warnings
 from typing import Any, Literal
 
 import arviz as az
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import xarray as xr
 from matplotlib.gridspec import GridSpec
 from patsy import dmatrices
 from scipy import stats
@@ -179,6 +177,7 @@ class PanelRegression(BaseExperiment):
 
     supports_ols = True
     supports_bayes = True
+    _deprecated_design_aliases = {"X": ("design", "X"), "y": ("design", "y")}
 
     def __init__(
         self,
@@ -283,38 +282,14 @@ def _build_design_matrices(self) -> None:
     def _prepare_data(self) -> None:
         """Bundle design matrices into an ``xr.Dataset``."""
         n = self._X_raw.shape[0]
-        self.design = xr.Dataset(
-            {
-                "X": xr.DataArray(
-                    self._X_raw,
-                    dims=["obs_ind", "coeffs"],
-                    coords={"obs_ind": np.arange(n), "coeffs": self.labels},
-                ),
-                "y": xr.DataArray(
-                    self._y_raw,
-                    dims=["obs_ind", "treated_units"],
-                    coords={"obs_ind": np.arange(n), "treated_units": ["unit_0"]},
-                ),
-            }
+        self.design = self._build_design_dataset(
+            self._X_raw,
+            self._y_raw,
+            obs_ind=np.arange(n),
+            coeffs=self.labels,
         )
         del self._X_raw, self._y_raw
 
-    @property
-    def X(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.design['X']`` instead."""
-        warnings.warn(
-            "X is deprecated, use design['X']", DeprecationWarning, stacklevel=2
-        )
-        return self.design["X"]
-
-    @property
-    def y(self) -> xr.DataArray:
-        """.. deprecated:: Use ``self.design['y']`` instead."""
-        warnings.warn(
-            "y is deprecated, use design['y']", DeprecationWarning, stacklevel=2
-        )
-        return self.design["y"]
-
     def algorithm(self) -> None:
         """Run the experiment algorithm: fit the model."""
         X = self.design["X"]