localproj 0.1.0__py3-none-any.whl

localproj/__init__.py

@@ -0,0 +1,19 @@
+"""Composable local projections for Python."""
+
+from .bootstrap import BootstrapResult
+from .core import lp
+from .estimators.bayesian import BayesianSULPResult
+from .plotting import plot_irf
+from .result import LPResult
+from .transforms import add_lags, lag, lead
+
+__all__ = [
+    "BayesianSULPResult",
+    "BootstrapResult",
+    "LPResult",
+    "add_lags",
+    "lag",
+    "lead",
+    "lp",
+    "plot_irf",
+]

localproj/_fitted.py

@@ -0,0 +1,203 @@
+"""Immutable, adapter-neutral fitted state used inside :mod:`localproj`."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+
+def _immutable_array(
+    value: Any,
+    *,
+    dtype: type[float] | type[int],
+    ndim: int,
+) -> np.ndarray:
+    """Copy values onto immutable bytes-backed storage."""
+
+    copied = np.array(value, dtype=dtype, copy=True, order="C")
+    if copied.ndim != ndim:
+        raise ValueError(f"expected a {ndim}-dimensional array, got {copied.ndim}")
+    return np.frombuffer(copied.tobytes(order="C"), dtype=copied.dtype).reshape(copied.shape)
+
+
+def _readonly_array(value: Any, *, ndim: int) -> np.ndarray:
+    return _immutable_array(value, dtype=float, ndim=ndim)
+
+
+def _readonly_int_array(value: Any) -> np.ndarray:
+    return _immutable_array(value, dtype=int, ndim=1)
+
+
+@dataclass(frozen=True)
+class LinearFitState:
+    """Normalized linear-model state needed by downstream estimators and inference.
+
+    The state contains only arrays, names, and flags. It deliberately contains no backend
+    model object, so callers outside estimator modules never need adapter-specific knowledge.
+    """
+
+    design: np.ndarray
+    residuals: np.ndarray
+    coefficients: np.ndarray
+    coefficient_names: tuple[str, ...]
+    is_iv: bool = False
+    has_fixed_effects: bool = False
+    origin_order: np.ndarray | None = None
+    sequence: np.ndarray | None = None
+    demeaned_design: np.ndarray | None = None
+    demeaned_outcome: np.ndarray | None = None
+
+    def __post_init__(self) -> None:
+        design = _readonly_array(self.design, ndim=2)
+        residuals = _readonly_array(self.residuals, ndim=1)
+        coefficients = _readonly_array(self.coefficients, ndim=1)
+        names = tuple(str(name) for name in self.coefficient_names)
+        if design.shape[0] != len(residuals):
+            raise ValueError("linear design and residuals have inconsistent row counts")
+        if design.shape[1] != len(names) or len(coefficients) != len(names):
+            raise ValueError("linear design, coefficients, and coefficient names are inconsistent")
+        object.__setattr__(self, "design", design)
+        object.__setattr__(self, "residuals", residuals)
+        object.__setattr__(self, "coefficients", coefficients)
+        object.__setattr__(self, "coefficient_names", names)
+
+        if self.origin_order is not None:
+            origin_order = _readonly_int_array(self.origin_order)
+            if len(origin_order) != design.shape[0]:
+                raise ValueError("Origin Order is not aligned with the linear design")
+            object.__setattr__(self, "origin_order", origin_order)
+        if self.sequence is not None:
+            sequence = _readonly_int_array(self.sequence)
+            if len(sequence) != design.shape[0]:
+                raise ValueError("estimation sequence is not aligned with the linear design")
+            object.__setattr__(self, "sequence", sequence)
+        if self.demeaned_design is not None:
+            demeaned_design = _readonly_array(self.demeaned_design, ndim=2)
+            if demeaned_design.shape != design.shape:
+                raise ValueError("demeaned design is not aligned with the linear design")
+            object.__setattr__(self, "demeaned_design", demeaned_design)
+        if self.demeaned_outcome is not None:
+            demeaned_outcome = _readonly_array(self.demeaned_outcome, ndim=1)
+            if len(demeaned_outcome) != design.shape[0]:
+                raise ValueError("demeaned outcome is not aligned with the linear design")
+            object.__setattr__(self, "demeaned_outcome", demeaned_outcome)
+
+
+@dataclass(frozen=True, init=False)
+class HorizonFit:
+    """Immutable fitted state for one outcome/horizon projection."""
+
+    horizon: int
+    _params: pd.Series = field(repr=False)
+    _covariance: pd.DataFrame = field(repr=False)
+    _residuals: pd.Series = field(repr=False)
+    _fitted: pd.Series = field(repr=False)
+    nobs: int
+    df_resid: int
+    _design_columns: tuple[str, ...]
+    linear: LinearFitState | None = field(default=None, repr=False)
+
+    def __init__(
+        self,
+        *,
+        horizon: int,
+        params: pd.Series,
+        covariance: pd.DataFrame,
+        residuals: pd.Series,
+        fitted: pd.Series,
+        nobs: int,
+        df_resid: int,
+        design_columns: list[str] | tuple[str, ...],
+        linear: LinearFitState | None = None,
+    ) -> None:
+        params_copy = params.copy(deep=True)
+        params_copy.index = params_copy.index.astype(str)
+        covariance_copy = covariance.copy(deep=True)
+        covariance_copy.index = covariance_copy.index.astype(str)
+        covariance_copy.columns = covariance_copy.columns.astype(str)
+        names = tuple(str(name) for name in design_columns)
+        if list(covariance_copy.index) != list(covariance_copy.columns):
+            raise ValueError("fit covariance row and column labels must match")
+        if any(name not in covariance_copy.index for name in params_copy.index):
+            raise ValueError("fit covariance is missing parameter labels")
+
+        object.__setattr__(self, "horizon", int(horizon))
+        object.__setattr__(self, "_params", params_copy)
+        object.__setattr__(self, "_covariance", covariance_copy)
+        object.__setattr__(self, "_residuals", residuals.copy(deep=True))
+        object.__setattr__(self, "_fitted", fitted.copy(deep=True))
+        object.__setattr__(self, "nobs", int(nobs))
+        object.__setattr__(self, "df_resid", int(df_resid))
+        object.__setattr__(self, "_design_columns", names)
+        object.__setattr__(self, "linear", linear)
+
+    @property
+    def params(self) -> pd.Series:
+        """Return an independently owned coefficient vector."""
+
+        return self._params.copy(deep=True)
+
+    @property
+    def covariance(self) -> pd.DataFrame:
+        """Return an independently owned coefficient covariance matrix."""
+
+        return self._covariance.copy(deep=True)
+
+    @property
+    def residuals(self) -> pd.Series:
+        """Return independently owned residuals."""
+
+        return self._residuals.copy(deep=True)
+
+    @property
+    def fitted(self) -> pd.Series:
+        """Return independently owned fitted values."""
+
+        return self._fitted.copy(deep=True)
+
+    @property
+    def design_columns(self) -> list[str]:
+        """Return the fitted design-column names."""
+
+        return list(self._design_columns)
+
+    def with_params(self, params: pd.Series) -> HorizonFit:
+        """Return a replacement fit with a new coefficient vector.
+
+        The normalized linear state describes the original estimator coefficients and is
+        therefore omitted when a correction replaces them.
+        """
+
+        return HorizonFit(
+            horizon=self.horizon,
+            params=params,
+            covariance=self._covariance,
+            residuals=self._residuals,
+            fitted=self._fitted,
+            nobs=self.nobs,
+            df_resid=self.df_resid,
+            design_columns=self._design_columns,
+            linear=None,
+        )
+
+    def renamed(self, names: Mapping[str, str]) -> HorizonFit:
+        """Return a replacement fit with renamed coefficient labels."""
+
+        params = self._params.rename(index=names)
+        covariance = self._covariance.rename(index=names, columns=names)
+        design_columns = tuple(names.get(column, column) for column in self._design_columns)
+        return HorizonFit(
+            horizon=self.horizon,
+            params=params,
+            covariance=covariance,
+            residuals=self._residuals,
+            fitted=self._fitted,
+            nobs=self.nobs,
+            df_resid=self.df_resid,
+            design_columns=design_columns,
+            linear=self.linear,
+        )

localproj/bootstrap.py

@@ -0,0 +1,458 @@
+"""Bootstrap inference for local projections."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import pandas as pd
+from scipy.stats import norm
+
+from .vcov import parse_vcov
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ._fitted import HorizonFit
+    from .result import LPResult
+
+
+_BOOTSTRAP_METHOD_ALIASES = {
+    "wild": "wild",
+    "wild-residual": "wild",
+    "wild_residual": "wild",
+}
+
+_WEIGHT_ALIASES = {
+    "rademacher": "rademacher",
+    "rad": "rademacher",
+    "mammen": "mammen",
+    "normal": "normal",
+    "gaussian": "normal",
+}
+
+_INTERVAL_ALIASES = {
+    "percentile": "percentile",
+    "pct": "percentile",
+    "basic": "basic",
+    "reverse-percentile": "basic",
+    "reverse_percentile": "basic",
+    "normal": "normal",
+    "standard": "normal",
+}
+
+_BAND_ALIASES = {
+    "pointwise": "pointwise",
+    "point-wise": "pointwise",
+    "point_wise": "pointwise",
+    "sup-t": "sup-t",
+    "supt": "sup-t",
+    "max-t": "sup-t",
+    "maxt": "sup-t",
+    "simultaneous": "sup-t",
+}
+
+
+@dataclass
+class BootstrapResult:
+    """Bootstrap draws and interval helpers for an :class:`~localproj.result.LPResult`.
+
+    The object stores long-form bootstrap coefficient draws for the requested shock paths.
+    Pointwise percentile/basic/normal intervals are available for horizon-specific samples;
+    bootstrap sup-t bands additionally require the original LP to have been estimated with
+    ``sample="common"`` so the same wild-bootstrap weights preserve cross-horizon
+    dependence.
+    """
+
+    parent: LPResult
+    estimates: pd.DataFrame
+    reps: int
+    method: str
+    weights: str
+    seed: int | None = None
+
+    @property
+    def horizons(self) -> list[int]:
+        """Horizons represented by the bootstrap draws."""
+
+        return self.parent.horizons
+
+    @property
+    def outcome_names(self) -> list[str]:
+        """Outcome names represented by the bootstrap draws."""
+
+        return self.parent.outcome_names
+
+    @property
+    def shock_names(self) -> list[str]:
+        """Shock names represented by the bootstrap draws."""
+
+        return self.parent.shock_names
+
+    @property
+    def vcov_type(self) -> str:
+        """Short label used by plotting/summary helpers."""
+
+        return f"bootstrap-{self.method}-{self.weights}"
+
+    @staticmethod
+    def _normalize_interval(interval: str) -> str:
+        value = interval.lower().replace("_", "-")
+        if value not in _INTERVAL_ALIASES:
+            raise ValueError("interval must be 'percentile', 'basic', or 'normal'")
+        return _INTERVAL_ALIASES[value]
+
+    @staticmethod
+    def _normalize_band(band: str) -> str:
+        value = band.lower().replace("_", "-")
+        if value not in _BAND_ALIASES:
+            raise ValueError("band must be 'pointwise' or 'sup-t'")
+        return _BAND_ALIASES[value]
+
+    def _selected_estimates(
+        self,
+        *,
+        outcome: str | Iterable[str] | None,
+        shock: str | Iterable[str] | None,
+    ) -> pd.DataFrame:
+        selected_outcomes = self.parent._select(
+            outcome, available=self.outcome_names, name="outcome"
+        )
+        selected_shocks = self.parent._select(shock, available=self.shock_names, name="shock")
+        table = self.estimates[
+            self.estimates["outcome"].isin(selected_outcomes)
+            & self.estimates["shock"].isin(selected_shocks)
+        ]
+        if table.empty:
+            raise ValueError("bootstrap selection produced no rows")
+        return table
+
+    def tidy(
+        self,
+        level: float = 0.95,
+        *,
+        interval: str = "percentile",
+        band: str = "pointwise",
+        outcome: str | Iterable[str] | None = None,
+        shock: str | Iterable[str] | None = None,
+        draws: int | None = None,
+        seed: int | None = None,
+    ) -> pd.DataFrame:
+        """Return bootstrap confidence intervals in long form.
+
+        Parameters ``draws`` and ``seed`` are accepted for compatibility with the generic
+        plotting helper; bootstrap draws are fixed when :meth:`LPResult.bootstrap` is
+        called, so they are ignored here.
+        """
+
+        del draws, seed
+        if not 0 < level < 1:
+            raise ValueError("level must be between 0 and 1")
+        interval_type = self._normalize_interval(interval)
+        band_type = self._normalize_band(band)
+        if band_type == "sup-t" and self.parent.metadata.get("sample") != "common":
+            raise NotImplementedError("bootstrap sup-t bands require sample='common'")
+
+        draws_table = self._selected_estimates(outcome=outcome, shock=shock)
+        original = self.parent.tidy(level=level)
+        original = original[
+            original["outcome"].isin(draws_table["outcome"].unique())
+            & original["shock"].isin(draws_table["shock"].unique())
+        ].copy()
+        original_indexed = original.set_index(["outcome", "shock", "horizon"]).rename(
+            columns={"std_error": "analytic_std_error"}
+        )
+
+        alpha = 1.0 - level
+        lower_q = alpha / 2.0
+        upper_q = 1.0 - alpha / 2.0
+        z_critical = float(norm.ppf(upper_q))
+
+        grouped = draws_table.groupby(["outcome", "shock", "horizon"], sort=False)["estimate"]
+        quantiles = grouped.quantile([lower_q, upper_q]).unstack()
+        quantiles.columns = ["boot_q_low", "boot_q_high"]
+        boot_std = grouped.std(ddof=1).rename("std_error")
+        summary = original_indexed.join(boot_std).join(quantiles)
+
+        critical_by_family: dict[tuple[str, str], float] = {}
+        if band_type == "sup-t":
+            for (outcome_name, shock_name), family_draws in draws_table.groupby(
+                ["outcome", "shock"], sort=False
+            ):
+                original_family = summary.loc[(outcome_name, shock_name)]
+                estimate_by_horizon = original_family["estimate"]
+                se_by_horizon = original_family["std_error"].replace(0.0, np.nan)
+                pivot = family_draws.pivot(index="rep", columns="horizon", values="estimate")
+                pivot = pivot.loc[:, self.horizons]
+                centered = pivot.sub(estimate_by_horizon, axis="columns")
+                studentized = centered.div(se_by_horizon, axis="columns").abs()
+                max_stat = studentized.max(axis=1).dropna()
+                if max_stat.empty:
+                    raise ValueError(
+                        "bootstrap sup-t bands require positive bootstrap standard errors"
+                    )
+                critical_by_family[(str(outcome_name), str(shock_name))] = float(
+                    max_stat.quantile(level)
+                )
+
+        rows: list[dict[str, Any]] = []
+        for key, values in summary.iterrows():
+            outcome_name, shock_name, horizon = key
+            estimate = float(values["estimate"])
+            std_error = float(values["std_error"])
+            if not np.isfinite(std_error) or std_error <= 0:
+                statistic = np.nan
+                p_value = np.nan
+            else:
+                statistic = estimate / std_error
+                p_value = 2.0 * (1.0 - norm.cdf(abs(statistic)))
+
+            if band_type == "sup-t":
+                critical = critical_by_family[(str(outcome_name), str(shock_name))]
+                conf_low = estimate - critical * std_error
+                conf_high = estimate + critical * std_error
+                interval_label = "bootstrap-sup-t"
+            elif interval_type == "percentile":
+                critical = np.nan
+                conf_low = float(values["boot_q_low"])
+                conf_high = float(values["boot_q_high"])
+                interval_label = interval_type
+            elif interval_type == "basic":
+                critical = np.nan
+                conf_low = 2.0 * estimate - float(values["boot_q_high"])
+                conf_high = 2.0 * estimate - float(values["boot_q_low"])
+                interval_label = interval_type
+            else:
+                critical = z_critical
+                conf_low = estimate - critical * std_error
+                conf_high = estimate + critical * std_error
+                interval_label = interval_type
+
+            rows.append(
+                {
+                    "outcome": outcome_name,
+                    "shock": shock_name,
+                    "horizon": int(horizon),
+                    "estimate": estimate,
+                    "std_error": std_error,
+                    "analytic_std_error": float(values["analytic_std_error"]),
+                    "statistic": statistic,
+                    "p_value": p_value,
+                    "conf_low": conf_low,
+                    "conf_high": conf_high,
+                    "level": level,
+                    "band": band_type,
+                    "interval": interval_label,
+                    "critical_value": critical,
+                    "reps": self.reps,
+                    "bootstrap_method": self.method,
+                    "bootstrap_weights": self.weights,
+                    "nobs": int(values["nobs"]),
+                    "df_resid": int(values["df_resid"]),
+                    "method": self.parent.method,
+                    "vcov": self.vcov_type,
+                }
+            )
+        return pd.DataFrame(rows)
+
+    def confint(
+        self,
+        level: float = 0.95,
+        *,
+        interval: str = "percentile",
+        band: str = "pointwise",
+        shock: str | Iterable[str] | None = None,
+        outcome: str | Iterable[str] | None = None,
+    ) -> pd.DataFrame:
+        """Return bootstrap confidence intervals indexed by horizon when possible."""
+
+        selected_outcomes = self.parent._select(
+            outcome, available=self.outcome_names, name="outcome"
+        )
+        selected_shocks = self.parent._select(shock, available=self.shock_names, name="shock")
+        table = self.tidy(level=level, interval=interval, band=band, outcome=outcome, shock=shock)
+        if len(selected_outcomes) == 1 and len(selected_shocks) == 1:
+            return table.set_index("horizon")[["conf_low", "conf_high"]]
+        return table[["outcome", "shock", "horizon", "conf_low", "conf_high"]].reset_index(
+            drop=True
+        )
+
+    def plot(
+        self,
+        level: float = 0.95,
+        *,
+        interval: str = "percentile",
+        band: str = "pointwise",
+        **kwargs: Any,
+    ) -> Any:
+        """Return a Plotnine IRF plot with bootstrap intervals."""
+
+        from .plotting import plot_irf
+
+        return plot_irf(self, level=level, band=band, interval=interval, **kwargs)
+
+
+def _normalize_method(method: str) -> str:
+    value = method.lower().replace("_", "-")
+    if value not in _BOOTSTRAP_METHOD_ALIASES:
+        raise ValueError("bootstrap method must be 'wild'")
+    return _BOOTSTRAP_METHOD_ALIASES[value]
+
+
+def _normalize_weights(weights: str) -> str:
+    value = weights.lower().replace("_", "-")
+    if value not in _WEIGHT_ALIASES:
+        raise ValueError("wild bootstrap weights must be 'rademacher', 'mammen', or 'normal'")
+    return _WEIGHT_ALIASES[value]
+
+
+def _is_cluster_vcov(vcov: Any) -> bool:
+    return isinstance(vcov, dict) and "type" not in vcov and "kind" not in vcov
+
+
+def _validate_bootstrap_scope(result: LPResult) -> None:
+    metadata = result.metadata
+    if metadata.get("backend") != "pyfixest" or metadata.get("estimator") != "feols":
+        raise NotImplementedError("bootstrap inference currently supports regular PyFixest OLS LPs")
+    if metadata.get("iv") is not None or str(result.method).endswith("iv"):
+        raise NotImplementedError("bootstrap inference is not implemented for IV/proxy LPs")
+    if metadata.get("fixed_effects") not in {None, "0", "1"}:
+        raise NotImplementedError("bootstrap inference is not implemented for fixed effects")
+    if metadata.get("groupby") is not None:
+        raise NotImplementedError("bootstrap inference is not implemented for panel/grouped LPs")
+    requested_vcov = metadata.get("requested_vcov")
+    if _is_cluster_vcov(requested_vcov):
+        raise NotImplementedError(
+            "bootstrap inference is not implemented for clustered covariance specs"
+        )
+    if requested_vcov is not None:
+        spec = parse_vcov(requested_vcov)
+        if spec.kind.lower() in {"hac", "newey-west", "nw"}:
+            raise NotImplementedError(
+                "wild bootstrap inference is not implemented for HAC/Newey-West LPs"
+            )
+
+
+def _draw_wild_weights(
+    rng: np.random.Generator, *, reps: int, nobs: int, weights: str
+) -> np.ndarray:
+    if weights == "rademacher":
+        return rng.choice(np.array([-1.0, 1.0]), size=(reps, nobs))
+    if weights == "normal":
+        return rng.standard_normal(size=(reps, nobs))
+    if weights == "mammen":
+        sqrt5 = np.sqrt(5.0)
+        low = (1.0 - sqrt5) / 2.0
+        high = (1.0 + sqrt5) / 2.0
+        probability_low = (sqrt5 + 1.0) / (2.0 * sqrt5)
+        return np.where(rng.random(size=(reps, nobs)) < probability_low, low, high)
+    raise ValueError(f"unknown wild bootstrap weights: {weights!r}")
+
+
+def _linear_design(fit: HorizonFit) -> tuple[np.ndarray, np.ndarray, np.ndarray, list[str]]:
+    linear = fit.linear
+    if linear is None:
+        raise NotImplementedError("bootstrap inference requires normalized linear-fit state")
+    if linear.is_iv:
+        raise NotImplementedError("bootstrap inference is not implemented for IV/proxy LPs")
+    if linear.has_fixed_effects:
+        raise NotImplementedError("bootstrap inference is not implemented for fixed effects")
+    return (
+        linear.design,
+        linear.residuals,
+        linear.coefficients,
+        list(linear.coefficient_names),
+    )
+
+
+def _bootstrap_fit_coefficients(
+    fit: HorizonFit,
+    *,
+    shock_names: list[str],
+    weights_matrix: np.ndarray,
+) -> pd.DataFrame:
+    x, residual, beta, names = _linear_design(fit)
+    missing = [shock for shock in shock_names if shock not in names]
+    if missing:
+        raise ValueError(
+            f"shock coefficient(s) {missing!r} are not in the fitted model for horizon {fit.horizon}"
+        )
+    if weights_matrix.shape[1] != x.shape[0]:
+        raise ValueError("wild bootstrap weight dimension does not match horizon sample size")
+
+    bread = np.linalg.pinv(x.T @ x)
+    scores = (weights_matrix * residual[None, :]) @ x
+    beta_star = beta[None, :] + scores @ bread.T
+    reps = weights_matrix.shape[0]
+
+    rows: list[pd.DataFrame] = []
+    for shock in shock_names:
+        position = names.index(shock)
+        rows.append(
+            pd.DataFrame(
+                {
+                    "rep": np.arange(reps, dtype=int),
+                    "horizon": fit.horizon,
+                    "shock": shock,
+                    "estimate": beta_star[:, position],
+                }
+            )
+        )
+    return pd.concat(rows, ignore_index=True)
+
+
+def bootstrap(
+    result: LPResult,
+    *,
+    reps: int = 999,
+    method: str = "wild",
+    weights: str = "rademacher",
+    seed: int | None = None,
+) -> BootstrapResult:
+    """Generate bootstrap coefficient draws for a fitted regular LP."""
+
+    if reps < 2:
+        raise ValueError("reps must be at least 2")
+    method_type = _normalize_method(method)
+    weight_type = _normalize_weights(weights)
+    _validate_bootstrap_scope(result)
+
+    rng = np.random.default_rng(seed)
+    common_sample = result.metadata.get("sample") == "common"
+    common_weights: np.ndarray | None = None
+    rows: list[pd.DataFrame] = []
+    for outcome_name in result.outcome_names:
+        for horizon in result.horizons:
+            fit = result._fit_for(outcome_name, horizon)
+            if common_sample:
+                if common_weights is None:
+                    common_weights = _draw_wild_weights(
+                        rng, reps=reps, nobs=fit.nobs, weights=weight_type
+                    )
+                elif common_weights.shape[1] != fit.nobs:
+                    raise ValueError(
+                        "sample='common' bootstrap requires identical horizon sample sizes"
+                    )
+                weights_matrix = common_weights
+            else:
+                weights_matrix = _draw_wild_weights(
+                    rng, reps=reps, nobs=fit.nobs, weights=weight_type
+                )
+            fit_draws = _bootstrap_fit_coefficients(
+                fit,
+                shock_names=result.shock_names,
+                weights_matrix=weights_matrix,
+            )
+            fit_draws.insert(1, "outcome", outcome_name)
+            rows.append(fit_draws)
+
+    estimates = pd.concat(rows, ignore_index=True)
+    estimates = estimates[["rep", "outcome", "shock", "horizon", "estimate"]]
+    return BootstrapResult(
+        parent=result,
+        estimates=estimates,
+        reps=reps,
+        method=method_type,
+        weights=weight_type,
+        seed=seed,
+    )