geds-python 0.1.0a2__py3-none-any.whl

geds/__init__.py

@@ -0,0 +1,13 @@
+"""Python access to the GeDS R package."""
+
+from ._backend import BackendUnavailableError, diagnostics
+from ._estimators import GeDSGeneralizedRegressor, GeDSRegressor
+
+__all__ = [
+    "BackendUnavailableError",
+    "GeDSGeneralizedRegressor",
+    "GeDSRegressor",
+    "diagnostics",
+]
+
+__version__ = "0.1.0a2"

geds/_backend.py

@@ -0,0 +1,290 @@
+"""Lazy, narrowly scoped access to the R implementation of GeDS."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+import ctypes
+from importlib.metadata import version
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import sys
+from typing import Any, Iterator
+
+import numpy as np
+import pandas as pd
+
+
+class BackendUnavailableError(RuntimeError):
+    """Raised when R, rpy2, or the GeDS R package is unavailable."""
+
+
+_DLL_HANDLES: list[Any] = []
+MIN_GEDS_VERSION = "0.3.6"
+
+
+def _version_key(path: Path) -> tuple[int, ...]:
+    match = re.search(r"R-(\d+(?:\.\d+)*)$", path.name)
+    return tuple(int(part) for part in match.group(1).split(".")) if match else ()
+
+
+def _discover_r_home() -> Path:
+    configured = os.environ.get("R_HOME")
+    if configured and (Path(configured) / "bin").is_dir():
+        return Path(configured)
+
+    if os.name == "nt":
+        roots = [Path(os.environ.get("ProgramFiles", r"C:\Program Files")) / "R"]
+        candidates = [
+            path
+            for root in roots
+            if root.is_dir()
+            for path in root.glob("R-*")
+            if (path / "bin" / "Rscript.exe").is_file()
+        ]
+        if candidates:
+            return max(candidates, key=_version_key)
+
+    rscript = shutil.which("Rscript")
+    if rscript:
+        executable = Path(rscript).resolve()
+        try:
+            reported_home = subprocess.run(
+                [str(executable), "--vanilla", "-e", "cat(R.home())"],
+                check=True,
+                capture_output=True,
+                text=True,
+            ).stdout.strip()
+        except (OSError, subprocess.CalledProcessError):
+            reported_home = ""
+        if reported_home and (Path(reported_home) / "bin").is_dir():
+            return Path(reported_home)
+
+    raise BackendUnavailableError(
+        "R was not found. Install R and either put Rscript on PATH or set R_HOME."
+    )
+
+
+def _configure_r_process() -> Path:
+    """Configure the current process before rpy2 imports R's shared library."""
+    r_home = _discover_r_home()
+    os.environ["R_HOME"] = str(r_home)
+
+    if os.name == "nt":
+        r_bin = r_home / "bin" / "x64"
+        if not r_bin.is_dir():
+            r_bin = r_home / "bin"
+        os.environ["PATH"] = os.pathsep.join(
+            (str(r_bin), str(r_home / "bin"), os.environ.get("PATH", ""))
+        )
+        if hasattr(os, "add_dll_directory"):
+            _DLL_HANDLES.append(os.add_dll_directory(str(r_bin)))
+        # R loads package DLLs itself. On current Windows/Python combinations,
+        # registering the directory with the OS is also required for their
+        # transitive dependencies (for example stats.dll -> R.dll).
+        if not ctypes.windll.kernel32.SetDllDirectoryW(str(r_bin)):
+            raise BackendUnavailableError(
+                f"Windows could not register R's DLL directory: {r_bin}"
+            )
+        # Explicitly retain R's core DLLs as well. R 4.6 can otherwise start
+        # successfully while later failing to load recommended packages such
+        # as stats because their Rblas/Rlapack dependencies are not found.
+        for dll_name in ("R.dll", "Rblas.dll", "Rlapack.dll", "Riconv.dll"):
+            dll_path = r_bin / dll_name
+            if dll_path.is_file():
+                try:
+                    _DLL_HANDLES.append(ctypes.WinDLL(str(dll_path)))
+                except OSError as exc:
+                    raise BackendUnavailableError(
+                        f"Windows could not load R's core library: {dll_path}"
+                    ) from exc
+
+    return r_home
+
+
+class RBackend:
+    """Own the embedded-R session and keep fitted models opaque."""
+
+    def __init__(self) -> None:
+        self.r_home = _configure_r_process()
+        rpy2_situation = None
+        original_get_r_flags = None
+        try:
+            # rpy2 3.6.x probes ``R CMD config --ldflags`` before loading
+            # R.dll. Some Windows R builds return no stdout for that query;
+            # rpy2 then raises IndexError instead of taking its normal
+            # Windows DLL-directory fallback. Translate only that empty-output
+            # case into the exception the fallback already handles.
+            if os.name == "nt":
+                import rpy2.situation as rpy2_situation
+
+                original_get_r_flags = rpy2_situation.get_r_flags
+
+                def get_r_flags_with_windows_fallback(*args: Any, **kwargs: Any) -> Any:
+                    try:
+                        return original_get_r_flags(*args, **kwargs)
+                    except IndexError as exc:
+                        raise subprocess.CalledProcessError(1, "R CMD config") from exc
+
+                rpy2_situation.get_r_flags = get_r_flags_with_windows_fallback
+
+            import rpy2.robjects as ro
+            from rpy2.rinterface_lib import openrlib
+            from rpy2.robjects import default_converter, pandas2ri
+            from rpy2.robjects.packages import importr
+        except Exception as exc:  # pragma: no cover - depends on host setup
+            raise BackendUnavailableError(
+                "rpy2 could not initialize embedded R. Run geds.diagnostics() "
+                "and verify that R and rpy2 use compatible versions."
+            ) from exc
+        finally:
+            if rpy2_situation is not None and original_get_r_flags is not None:
+                rpy2_situation.get_r_flags = original_get_r_flags
+
+        self.ro = ro
+        self._openrlib = openrlib
+        self._converter = default_converter + pandas2ri.converter
+
+        extra_library = os.environ.get("GEDS_R_LIBRARY")
+        if extra_library:
+            current = list(ro.r(".libPaths()"))
+            ro.r[".libPaths"](ro.StrVector([extra_library, *current]))
+
+        try:
+            self.geds = importr("GeDS")
+            self.stats = importr("stats")
+        except Exception as exc:
+            raise BackendUnavailableError(
+                "The GeDS R package could not be loaded. Install GeDS into a "
+                "library visible to this R installation."
+            ) from exc
+
+        self.geds_version = str(
+            self.ro.r("as.character(packageVersion('GeDS'))")[0]
+        )
+        is_supported = bool(
+            self.ro.r(
+                "packageVersion('GeDS') >= "
+                f"package_version('{MIN_GEDS_VERSION}')"
+            )[0]
+        )
+        if not is_supported:
+            raise BackendUnavailableError(
+                f"GeDS {self.geds_version} is installed, but geds-python "
+                f"requires GeDS >= {MIN_GEDS_VERSION}."
+            )
+
+    @contextmanager
+    def locked(self) -> Iterator[None]:
+        """Serialize access to R's process-global runtime."""
+        with self._openrlib.rlock:
+            yield
+
+    def dataframe_to_r(self, frame: pd.DataFrame) -> Any:
+        with self.locked(), self._converter.context():
+            return self.ro.conversion.get_conversion().py2rpy(frame)
+
+    def vector(self, values: Any) -> Any:
+        return self.ro.FloatVector(np.asarray(values, dtype=float))
+
+    def formula(self, expression: str) -> Any:
+        return self.ro.Formula(expression)
+
+    def family(self, name: str, link: str | None) -> Any:
+        normalized = name.lower()
+        functions = {
+            "gaussian": "gaussian",
+            "poisson": "poisson",
+            "quasipoisson": "quasipoisson",
+            "binomial": "binomial",
+            "quasibinomial": "quasibinomial",
+            "gamma": "Gamma",
+        }
+        if normalized not in functions:
+            choices = ", ".join(sorted(functions))
+            raise ValueError(f"Unsupported family {name!r}; choose one of: {choices}.")
+        function = getattr(self.stats, functions[normalized])
+        return function() if link is None else function(link=link)
+
+    def fit(self, function: str, formula: Any, data: Any, **kwargs: Any) -> Any:
+        with self.locked():
+            return getattr(self.geds, function)(formula, data=data, **kwargs)
+
+    def predict(
+        self, model: Any, data: Any, order: int, prediction_type: str
+    ) -> np.ndarray:
+        with self.locked():
+            result = self.stats.predict(
+                model, newdata=data, n=order, type=prediction_type
+            )
+        return np.asarray(result, dtype=float)
+
+    def coefficients(self, model: Any, order: int) -> Any:
+        with self.locked():
+            return self.to_python(self.stats.coef(model, n=order))
+
+    def knots(self, model: Any, order: int) -> Any:
+        with self.locked():
+            return self.to_python(
+                self.stats.knots(model, n=order, options="internal")
+            )
+
+    def deviance(self, model: Any, order: int) -> float:
+        with self.locked():
+            return float(self.stats.deviance(model, n=order)[0])
+
+    def component(self, model: Any, name: str) -> Any:
+        try:
+            return self.to_python(model.rx2(name))
+        except Exception:
+            return None
+
+    def to_python(self, value: Any) -> Any:
+        """Convert extracted values without recursively converting a model."""
+        vectors = self.ro.vectors
+        if value is self.ro.NULL:
+            return None
+        if isinstance(value, vectors.ListVector):
+            names = list(value.names) if value.names is not self.ro.NULL else []
+            converted = [self.to_python(item) for item in value]
+            if names and len(names) == len(converted) and all(names):
+                return dict(zip(names, converted))
+            return converted
+        if isinstance(value, vectors.StrVector):
+            result = np.asarray(value, dtype=str)
+        elif isinstance(
+            value, (vectors.FloatVector, vectors.IntVector, vectors.BoolVector)
+        ):
+            result = np.asarray(value)
+        else:
+            return value
+        return result.item() if result.ndim == 0 else result
+
+    def information(self) -> dict[str, str]:
+        with self.locked():
+            return {
+                "r_home": str(self.r_home),
+                "r_version": str(self.ro.r("R.version.string")[0]),
+                "geds_version": self.geds_version,
+                "minimum_geds_version": MIN_GEDS_VERSION,
+                "geds_library": str(self.ro.r("find.package('GeDS')")[0]),
+                "rpy2_version": version("rpy2"),
+                "python": sys.version.split()[0],
+            }
+
+
+_BACKEND: RBackend | None = None
+
+
+def get_backend() -> RBackend:
+    global _BACKEND
+    if _BACKEND is None:
+        _BACKEND = RBackend()
+    return _BACKEND
+
+
+def diagnostics() -> dict[str, str]:
+    """Return the versions and locations used by the Python/R bridge."""
+    return get_backend().information()

geds/_estimators.py

@@ -0,0 +1,385 @@
+"""Scikit-learn-style estimators that delegate all statistics to R GeDS."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import pickle
+from typing import Any, Sequence
+
+import numpy as np
+import pandas as pd
+from pandas.api.types import is_numeric_dtype
+from sklearn.base import BaseEstimator, RegressorMixin
+from sklearn.utils.validation import check_is_fitted
+
+from ._backend import get_backend
+
+
+FeatureSelector = Sequence[str | int] | None
+
+
+class _GeDSBase(RegressorMixin, BaseEstimator):
+    _fit_function = ""
+
+    def _validate_configuration(self) -> None:
+        if self.order not in (2, 3, 4):
+            raise ValueError("order must be 2, 3, or 4.")
+        if not self.higher_order and self.order != 2:
+            raise ValueError("order must be 2 when higher_order=False.")
+        if self.beta is not None and not 0 <= self.beta <= 1:
+            raise ValueError("beta must lie in [0, 1].")
+        if not 0 <= self.phi <= 1:
+            raise ValueError("phi must lie in [0, 1].")
+        if not isinstance(self.q, (int, np.integer)) or self.q < 1:
+            raise ValueError("q must be a positive integer.")
+        if self.stop_type not in {"SR", "RD", "LR"}:
+            raise ValueError("stop_type must be 'SR', 'RD', or 'LR'.")
+        for name in ("min_internal_knots", "max_internal_knots"):
+            value = getattr(self, name)
+            if value is not None and (
+                not isinstance(value, (int, np.integer)) or value < 0
+            ):
+                raise ValueError(f"{name} must be a non-negative integer or None.")
+        if (
+            self.min_internal_knots is not None
+            and self.max_internal_knots is not None
+            and self.min_internal_knots > self.max_internal_knots
+        ):
+            raise ValueError(
+                "min_internal_knots must not exceed max_internal_knots."
+            )
+        self._validate_range("x_range", self.x_range)
+        self._validate_range("y_range", self.y_range)
+
+    @staticmethod
+    def _validate_range(name: str, value: Sequence[float] | None) -> None:
+        if value is None:
+            return
+        array = np.asarray(value, dtype=float)
+        if array.shape != (2,) or not np.isfinite(array).all() or array[0] >= array[1]:
+            raise ValueError(
+                f"{name} must contain two finite, strictly increasing values."
+            )
+
+    @staticmethod
+    def _frame(X: Any) -> tuple[pd.DataFrame, bool]:
+        if isinstance(X, pd.DataFrame):
+            if X.columns.has_duplicates:
+                raise ValueError("X must not contain duplicate column names.")
+            return X.copy(), True
+        array = np.asarray(X)
+        if array.ndim != 2:
+            raise ValueError("X must be a two-dimensional array or DataFrame.")
+        return (
+            pd.DataFrame(array, columns=[f"x{i}" for i in range(array.shape[1])]),
+            False,
+        )
+
+    @staticmethod
+    def _resolve(
+        selectors: FeatureSelector, columns: list[Any], *, default: list[int]
+    ) -> list[int]:
+        if selectors is None:
+            return default
+        if isinstance(selectors, (str, int)):
+            selectors = [selectors]
+        indices: list[int] = []
+        for selector in selectors:
+            if isinstance(selector, str):
+                if selector not in columns:
+                    raise ValueError(f"Unknown feature {selector!r}.")
+                index = columns.index(selector)
+            elif isinstance(selector, (int, np.integer)):
+                index = int(selector)
+                if index < 0 or index >= len(columns):
+                    raise ValueError(f"Feature index {index} is out of range.")
+            else:
+                raise TypeError("Feature selectors must be column names or indices.")
+            if index not in indices:
+                indices.append(index)
+        return indices
+
+    def _prepare_training_data(
+        self, X: Any, y: Any, sample_weight: Any
+    ) -> tuple[pd.DataFrame, str, Any | None]:
+        frame, named_input = self._frame(X)
+        y_array = np.asarray(y, dtype=float)
+        if y_array.ndim != 1 or len(y_array) != len(frame):
+            raise ValueError("y must be one-dimensional and have the same length as X.")
+        if not np.isfinite(y_array).all():
+            raise ValueError("y must contain only finite values.")
+
+        columns = list(frame.columns)
+        spline = self._resolve(
+            self.spline_features, columns, default=list(range(len(columns)))
+        )
+        if not spline:
+            raise ValueError("At least one spline feature is required.")
+        remainder = [index for index in range(len(columns)) if index not in spline]
+        linear = self._resolve(self.linear_features, columns, default=remainder)
+        overlap = sorted(set(spline).intersection(linear))
+        if overlap:
+            raise ValueError("Spline and linear feature selections must not overlap.")
+        non_numeric = [
+            columns[index]
+            for index in spline
+            if not is_numeric_dtype(frame.iloc[:, index])
+        ]
+        if non_numeric:
+            raise TypeError(f"Spline features must be numeric; got {non_numeric}.")
+        if frame.isna().to_numpy().any():
+            raise ValueError("X must not contain missing values.")
+
+        self.n_features_in_ = frame.shape[1]
+        self._input_columns_ = columns
+        self._named_input_ = named_input
+        if named_input and all(isinstance(column, str) for column in columns):
+            self.feature_names_in_ = np.asarray(columns, dtype=object)
+        self._internal_columns_ = [f"x{index}" for index in range(len(columns))]
+        self._spline_indices_ = spline
+        self._linear_indices_ = linear
+        self.spline_features_ = np.asarray(
+            [columns[index] for index in spline], dtype=object
+        )
+        self.linear_features_ = np.asarray(
+            [columns[index] for index in linear], dtype=object
+        )
+
+        internal = frame.copy()
+        internal.columns = self._internal_columns_
+        internal.insert(0, "response", y_array)
+        spline_term = "f(" + ", ".join(self._internal_columns_[i] for i in spline) + ")"
+        linear_terms = [self._internal_columns_[i] for i in linear]
+        formula = "response ~ " + " + ".join([spline_term, *linear_terms])
+        self.formula_ = formula
+
+        weights = None
+        if sample_weight is not None:
+            weight_array = np.asarray(sample_weight, dtype=float)
+            if weight_array.ndim != 1 or len(weight_array) != len(frame):
+                raise ValueError(
+                    "sample_weight must be one-dimensional and match the length of X."
+                )
+            if not np.isfinite(weight_array).all() or np.any(weight_array < 0):
+                raise ValueError(
+                    "sample_weight must contain only finite, non-negative values."
+                )
+            weights = get_backend().vector(weight_array)
+        return internal, formula, weights
+
+    def _prepare_new_data(self, X: Any) -> pd.DataFrame:
+        check_is_fitted(self, "_r_model_")
+        frame, named_input = self._frame(X)
+        if frame.shape[1] != self.n_features_in_:
+            raise ValueError(
+                f"X has {frame.shape[1]} features; expected {self.n_features_in_}."
+            )
+        if self._named_input_:
+            missing = [
+                name for name in self._input_columns_ if name not in frame.columns
+            ]
+            if missing:
+                raise ValueError(f"X is missing columns: {missing}.")
+            frame = frame.loc[:, self._input_columns_]
+        elif named_input:
+            frame = frame.iloc[:, : self.n_features_in_]
+        if frame.isna().to_numpy().any():
+            raise ValueError("X must not contain missing values.")
+        non_numeric = [
+            self._input_columns_[index]
+            for index in self._spline_indices_
+            if not is_numeric_dtype(frame.iloc[:, index])
+        ]
+        if non_numeric:
+            raise TypeError(f"Spline features must be numeric; got {non_numeric}.")
+        frame.columns = self._internal_columns_
+        return frame
+
+    def _common_fit_kwargs(self, weights: Any | None) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {
+            "phi": self.phi,
+            "q": self.q,
+            "show_iters": self.verbose,
+            "stoptype": self.stop_type,
+            "higher_order": self.higher_order,
+        }
+        optional = {
+            "beta": self.beta,
+            "min_intknots": self.min_internal_knots,
+            "max_intknots": self.max_internal_knots,
+            "Xextr": (
+                get_backend().vector(self.x_range) if self.x_range is not None else None
+            ),
+            "Yextr": (
+                get_backend().vector(self.y_range) if self.y_range is not None else None
+            ),
+            "weights": weights,
+        }
+        kwargs.update(
+            {key: value for key, value in optional.items() if value is not None}
+        )
+        return kwargs
+
+    def _finish_fit(self, model: Any) -> None:
+        backend = get_backend()
+        self._r_model_ = model
+        self.coef_ = backend.coefficients(model, self.order)
+        self.knots_ = backend.knots(model, self.order)
+        self.deviance_ = backend.deviance(model, self.order)
+        self.n_iter_ = backend.component(model, "iters")
+
+    def predict(self, X: Any) -> np.ndarray:
+        frame = self._prepare_new_data(X)
+        backend = get_backend()
+        return backend.predict(
+            self._r_model_, backend.dataframe_to_r(frame), self.order, "response"
+        )
+
+    def predict_link(self, X: Any) -> np.ndarray:
+        """Return predictions on the link scale."""
+        frame = self._prepare_new_data(X)
+        backend = get_backend()
+        return backend.predict(
+            self._r_model_, backend.dataframe_to_r(frame), self.order, "link"
+        )
+
+    def get_coefficients(self, order: int | None = None) -> Any:
+        check_is_fitted(self, "_r_model_")
+        selected_order = self.order if order is None else order
+        self._validate_requested_order(selected_order)
+        return get_backend().coefficients(self._r_model_, selected_order)
+
+    def get_knots(self, order: int | None = None) -> Any:
+        check_is_fitted(self, "_r_model_")
+        selected_order = self.order if order is None else order
+        self._validate_requested_order(selected_order)
+        return get_backend().knots(self._r_model_, selected_order)
+
+    def _validate_requested_order(self, order: int) -> None:
+        if order not in (2, 3, 4):
+            raise ValueError("order must be 2, 3, or 4.")
+        if not self.higher_order and order != 2:
+            raise ValueError("Only order 2 is available when higher_order=False.")
+
+    def save(self, path: str | Path) -> None:
+        """Serialize the estimator and its opaque R model with pickle."""
+        check_is_fitted(self, "_r_model_")
+        with Path(path).open("wb") as stream:
+            pickle.dump(self, stream, protocol=pickle.HIGHEST_PROTOCOL)
+
+    @classmethod
+    def load(cls, path: str | Path) -> "_GeDSBase":
+        """Load an estimator saved by :meth:`save` from a trusted source."""
+        with Path(path).open("rb") as stream:
+            model = pickle.load(stream)
+        if not isinstance(model, cls):
+            raise TypeError(f"The file does not contain a {cls.__name__} estimator.")
+        return model
+
+
+class GeDSRegressor(_GeDSBase):
+    """Normal-response GeDS estimator backed by ``GeDS::NGeDS``."""
+
+    _fit_function = "NGeDS"
+
+    def __init__(
+        self,
+        *,
+        spline_features: FeatureSelector = None,
+        linear_features: FeatureSelector = None,
+        order: int = 3,
+        beta: float = 0.5,
+        phi: float = 0.99,
+        min_internal_knots: int | None = None,
+        max_internal_knots: int | None = None,
+        q: int = 2,
+        x_range: Sequence[float] | None = None,
+        y_range: Sequence[float] | None = None,
+        stop_type: str = "RD",
+        higher_order: bool = True,
+        verbose: bool = False,
+    ) -> None:
+        self.spline_features = spline_features
+        self.linear_features = linear_features
+        self.order = order
+        self.beta = beta
+        self.phi = phi
+        self.min_internal_knots = min_internal_knots
+        self.max_internal_knots = max_internal_knots
+        self.q = q
+        self.x_range = x_range
+        self.y_range = y_range
+        self.stop_type = stop_type
+        self.higher_order = higher_order
+        self.verbose = verbose
+
+    def fit(self, X: Any, y: Any, sample_weight: Any = None) -> "GeDSRegressor":
+        self._validate_configuration()
+        frame, formula, weights = self._prepare_training_data(X, y, sample_weight)
+        backend = get_backend()
+        model = backend.fit(
+            self._fit_function,
+            backend.formula(formula),
+            backend.dataframe_to_r(frame),
+            **self._common_fit_kwargs(weights),
+        )
+        self._finish_fit(model)
+        return self
+
+
+class GeDSGeneralizedRegressor(_GeDSBase):
+    """Exponential-family GeDS estimator backed by ``GeDS::GGeDS``."""
+
+    _fit_function = "GGeDS"
+
+    def __init__(
+        self,
+        *,
+        family: str = "gaussian",
+        link: str | None = None,
+        spline_features: FeatureSelector = None,
+        linear_features: FeatureSelector = None,
+        order: int = 3,
+        beta: float | None = None,
+        phi: float = 0.99,
+        min_internal_knots: int | None = None,
+        max_internal_knots: int | None = None,
+        q: int = 2,
+        x_range: Sequence[float] | None = None,
+        y_range: Sequence[float] | None = None,
+        stop_type: str = "SR",
+        higher_order: bool = True,
+        verbose: bool = False,
+    ) -> None:
+        self.family = family
+        self.link = link
+        self.spline_features = spline_features
+        self.linear_features = linear_features
+        self.order = order
+        self.beta = beta
+        self.phi = phi
+        self.min_internal_knots = min_internal_knots
+        self.max_internal_knots = max_internal_knots
+        self.q = q
+        self.x_range = x_range
+        self.y_range = y_range
+        self.stop_type = stop_type
+        self.higher_order = higher_order
+        self.verbose = verbose
+
+    def fit(
+        self, X: Any, y: Any, sample_weight: Any = None
+    ) -> "GeDSGeneralizedRegressor":
+        self._validate_configuration()
+        frame, formula, weights = self._prepare_training_data(X, y, sample_weight)
+        backend = get_backend()
+        kwargs = self._common_fit_kwargs(weights)
+        kwargs["family"] = backend.family(self.family, self.link)
+        model = backend.fit(
+            self._fit_function,
+            backend.formula(formula),
+            backend.dataframe_to_r(frame),
+            **kwargs,
+        )
+        self._finish_fit(model)
+        return self

geds/py.typed

@@ -0,0 +1 @@
+