plotnine 0.15.0.dev2__py3-none-any.whl → 0.15.1__py3-none-any.whl

plotnine/stats/smoothers.py

@@ -12,12 +12,9 @@ from ..exceptions import PlotnineError, PlotnineWarning
 
 if TYPE_CHECKING:
     import statsmodels.api as sm
-    from patsy.eval import EvalEnvironment
 
-    from plotnine.mapping import Environment
 
-
-def predictdf(data, xseq, **params) -> pd.DataFrame:
+def predictdf(data, xseq, params) -> pd.DataFrame:
     """
     Make prediction on the data
 
@@ -49,21 +46,21 @@ def predictdf(data, xseq, **params) -> pd.DataFrame:
     if not callable(method):
         msg = (
             "'method' should either be a string or a function"
-            "with the signature `func(data, xseq, **params)`"
+            "with the signature `func(data, xseq, params)`"
         )
         raise PlotnineError(msg)
 
-    return method(data, xseq, **params)
+    return method(data, xseq, params)
 
 
-def lm(data, xseq, **params) -> pd.DataFrame:
+def lm(data, xseq, params) -> pd.DataFrame:
     """
     Fit OLS / WLS if data has weight
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return lm_formula(data, xseq, **params)
+        return lm_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -96,14 +93,14 @@ def lm(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def lm_formula(data, xseq, **params) -> pd.DataFrame:
+def lm_formula(data, xseq, params) -> pd.DataFrame:
     """
     Fit OLS / WLS using a formula
     """
     import statsmodels.api as sm
     import statsmodels.formula.api as smf
 
-    eval_env = _to_patsy_env(params["environment"])
+    eval_env = params["environment"].to_patsy_env()
     formula = params["formula"]
     weights = data.get("weight", None)
 
@@ -140,14 +137,14 @@ def lm_formula(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def rlm(data, xseq, **params) -> pd.DataFrame:
+def rlm(data, xseq, params) -> pd.DataFrame:
     """
     Fit RLM
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return rlm_formula(data, xseq, **params)
+        return rlm_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -170,14 +167,14 @@ def rlm(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def rlm_formula(data, xseq, **params) -> pd.DataFrame:
+def rlm_formula(data, xseq, params) -> pd.DataFrame:
     """
     Fit RLM using a formula
     """
     import statsmodels.api as sm
     import statsmodels.formula.api as smf
 
-    eval_env = _to_patsy_env(params["environment"])
+    eval_env = params["environment"].to_patsy_env()
     formula = params["formula"]
     init_kwargs, fit_kwargs = separate_method_kwargs(
         params["method_args"], sm.RLM, sm.RLM.fit
@@ -196,14 +193,14 @@ def rlm_formula(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gls(data, xseq, **params) -> pd.DataFrame:
+def gls(data, xseq, params) -> pd.DataFrame:
     """
     Fit GLS
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return gls_formula(data, xseq, **params)
+        return gls_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -227,14 +224,14 @@ def gls(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gls_formula(data, xseq, **params):
+def gls_formula(data, xseq, params):
     """
     Fit GLL using a formula
     """
     import statsmodels.api as sm
     import statsmodels.formula.api as smf
 
-    eval_env = _to_patsy_env(params["environment"])
+    eval_env = params["environment"].to_patsy_env()
     formula = params["formula"]
     init_kwargs, fit_kwargs = separate_method_kwargs(
         params["method_args"], sm.GLS, sm.GLS.fit
@@ -258,14 +255,14 @@ def gls_formula(data, xseq, **params):
     return data
 
 
-def glm(data, xseq, **params) -> pd.DataFrame:
+def glm(data, xseq, params) -> pd.DataFrame:
     """
     Fit GLM
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return glm_formula(data, xseq, **params)
+        return glm_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -292,14 +289,14 @@ def glm(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def glm_formula(data, xseq, **params):
+def glm_formula(data, xseq, params):
     """
     Fit with GLM formula
     """
     import statsmodels.api as sm
     import statsmodels.formula.api as smf
 
-    eval_env = _to_patsy_env(params["environment"])
+    eval_env = params["environment"].to_patsy_env()
     init_kwargs, fit_kwargs = separate_method_kwargs(
         params["method_args"], sm.GLM, sm.GLM.fit
     )
@@ -321,7 +318,7 @@ def glm_formula(data, xseq, **params):
     return data
 
 
-def lowess(data, xseq, **params) -> pd.DataFrame:
+def lowess(data, xseq, params) -> pd.DataFrame:
     """
     Lowess fitting
     """
@@ -351,7 +348,7 @@ def lowess(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def loess(data, xseq, **params) -> pd.DataFrame:
+def loess(data, xseq, params) -> pd.DataFrame:
     """
     Loess smoothing
     """
@@ -402,7 +399,7 @@ def loess(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def mavg(data, xseq, **params) -> pd.DataFrame:
+def mavg(data, xseq, params) -> pd.DataFrame:
     """
     Fit moving average
     """
@@ -426,7 +423,7 @@ def mavg(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gpr(data, xseq, **params):
+def gpr(data, xseq, params):
     """
     Fit gaussian process
     """
@@ -593,16 +590,6 @@ def separate_method_kwargs(method_args, init_method, fit_method):
     return init_kwargs, fit_kwargs
 
 
-def _to_patsy_env(environment: Environment) -> EvalEnvironment:
-    """
-    Convert a plotnine environment to a patsy environment
-    """
-    from patsy.eval import EvalEnvironment
-
-    eval_env = EvalEnvironment(environment.namespaces)
-    return eval_env
-
-
 def _glm_family(family: str) -> sm.families.Family:
     """
     Get glm-family instance

plotnine/stats/stat.py

@@ -64,7 +64,7 @@ class stat(ABC, metaclass=Register):
 
     # Plot namespace, it gets its value when the plot is being
     # built.
-    environment: Environment | None = None
+    environment: Environment
 
     def __init__(
         self,
@@ -195,9 +195,9 @@ class stat(ABC, metaclass=Register):
 
         return data
 
-    def setup_params(self, data: pd.DataFrame) -> dict[str, Any]:
+    def setup_params(self, data: pd.DataFrame):
         """
-        Override this to verify or adjust parameters
+        Override this to verify and/or adjust parameters
 
         Parameters
         ----------
@@ -209,7 +209,6 @@ class stat(ABC, metaclass=Register):
         out :
             Parameters used by the stats.
         """
-        return self.params
 
     def setup_data(self, data: pd.DataFrame) -> pd.DataFrame:
         """
@@ -227,9 +226,7 @@ class stat(ABC, metaclass=Register):
         """
         return data
 
-    def finish_layer(
-        self, data: pd.DataFrame, params: dict[str, Any]
-    ) -> pd.DataFrame:
+    def finish_layer(self, data: pd.DataFrame) -> pd.DataFrame:
         """
         Modify data after the aesthetics have been mapped
 
@@ -257,9 +254,8 @@ class stat(ABC, metaclass=Register):
         """
         return data
 
-    @classmethod
     def compute_layer(
-        cls, data: pd.DataFrame, params: dict[str, Any], layout: Layout
+        self, data: pd.DataFrame, layout: Layout
     ) -> pd.DataFrame:
         """
         Calculate statistics for this layers
@@ -275,22 +271,20 @@ class stat(ABC, metaclass=Register):
         ----------
         data :
             Data points for all objects in a layer.
-        params :
-            Stat parameters
         layout :
             Panel layout information
         """
         check_required_aesthetics(
-            cls.REQUIRED_AES,
-            list(data.columns) + list(params.keys()),
-            cls.__name__,
+            self.REQUIRED_AES,
+            list(data.columns) + list(self.params.keys()),
+            self.__class__.__name__,
         )
 
         data = remove_missing(
             data,
-            na_rm=params.get("na_rm", False),
-            vars=list(cls.REQUIRED_AES | cls.NON_MISSING_AES),
-            name=cls.__name__,
+            na_rm=self.params.get("na_rm", False),
+            vars=list(self.REQUIRED_AES | self.NON_MISSING_AES),
+            name=self.__class__.__name__,
             finite=True,
         )
 
@@ -304,14 +298,11 @@ class stat(ABC, metaclass=Register):
             if len(pdata) == 0:
                 return pdata
             pscales = layout.get_scales(pdata["PANEL"].iloc[0])
-            return cls.compute_panel(pdata, pscales, **params)
+            return self.compute_panel(pdata, pscales)
 
         return groupby_apply(data, "PANEL", fn)
 
-    @classmethod
-    def compute_panel(
-        cls, data: pd.DataFrame, scales: pos_scales, **params: Any
-    ):
+    def compute_panel(self, data: pd.DataFrame, scales: pos_scales):
         """
         Calculate the statistics for all the groups
 
@@ -341,14 +332,12 @@ class stat(ABC, metaclass=Register):
 
         stats = []
         for _, old in data.groupby("group"):
-            new = cls.compute_group(old, scales, **params)
+            new = self.compute_group(old, scales)
             new.reset_index(drop=True, inplace=True)
             unique = uniquecols(old)
             missing = unique.columns.difference(new.columns)
             idx = [0] * len(new)
-            u = unique.loc[idx, missing].reset_index(  # pyright: ignore
-                drop=True
-            )
+            u = unique.loc[idx, missing].reset_index(drop=True)
             # concat can have problems with empty dataframes that
             # have an index
             if u.empty and len(u):
@@ -365,9 +354,8 @@ class stat(ABC, metaclass=Register):
         # it completely.
         return stats
 
-    @classmethod
     def compute_group(
-        cls, data: pd.DataFrame, scales: pos_scales, **params: Any
+        self, data: pd.DataFrame, scales: pos_scales
     ) -> pd.DataFrame:
         """
         Calculate statistics for the group
@@ -390,9 +378,9 @@ class stat(ABC, metaclass=Register):
             Parameters
         """
         msg = "{} should implement this method."
-        raise NotImplementedError(msg.format(cls.__name__))
+        raise NotImplementedError(msg.format(self.__class__.__name__))
 
-    def __radd__(self, plot: ggplot) -> ggplot:
+    def __radd__(self, other: ggplot) -> ggplot:
         """
         Add layer representing stat object on the right
 
@@ -406,8 +394,8 @@ class stat(ABC, metaclass=Register):
         out :
             ggplot object with added layer
         """
-        plot += self.to_layer()  # Add layer
-        return plot
+        other += self.to_layer()  # Add layer
+        return other
 
     def to_layer(self) -> layer:
         """

plotnine/stats/stat_bin.py

@@ -53,6 +53,10 @@ class stat_bin(stat):
     pad : bool, default=False
         If `True`{.py}, adds empty bins at either side of x.
         This ensures that frequency polygons touch 0.
+
+    See Also
+    --------
+    plotnine.histogram : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -100,7 +104,6 @@ class stat_bin(stat):
             and params["binwidth"] is None
             and params["bins"] is None
         ):
-            params = params.copy()
             params["bins"] = freedman_diaconis_bins(data["x"])
             msg = (
                 "'stat_bin()' using 'bins = {}'. "
@@ -108,10 +111,8 @@ class stat_bin(stat):
             )
             warn(msg.format(params["bins"]), PlotnineWarning)
 
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
+        params = self.params
         if params["breaks"] is not None:
             breaks = np.asarray(params["breaks"])
             if hasattr(scales.x, "transform"):

plotnine/stats/stat_bin_2d.py

@@ -35,6 +35,10 @@ class stat_bin_2d(stat):
         the stories in your data.
     drop : bool, default=False
         If `True`{.py}, removes all cells with zero counts.
+
+    See Also
+    --------
+    plotnine.geom_rect : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -66,18 +70,16 @@ class stat_bin_2d(stat):
     CREATES = {"xmin", "xmax", "ymin", "ymax", "count", "density"}
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         params["bins"] = dual_param(params["bins"])
         params["breaks"] = dual_param(params["breaks"])
         params["binwidth"] = dual_param(params["binwidth"])
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
-        bins = params["bins"]
-        breaks = params["breaks"]
-        binwidth = params["binwidth"]
-        drop = params["drop"]
+
+    def compute_group(self, data, scales):
+        bins = self.params["bins"]
+        breaks = self.params["breaks"]
+        binwidth = self.params["binwidth"]
+        drop = self.params["drop"]
         weight = data.get("weight")
 
         if weight is None:

plotnine/stats/stat_bindot.py

@@ -68,6 +68,7 @@ class stat_bindot(stat):
 
     See Also
     --------
+    plotnine.geom_dotplot : The default `geom` for this `stat`.
     plotnine.stat_bin
     """
 
@@ -113,18 +114,16 @@ class stat_bindot(stat):
             and params["binwidth"] is None
             and params["bins"] is None
         ):
-            params = params.copy()
-            params["bins"] = freedman_diaconis_bins(data["x"])
-            msg = (
-                "'stat_bin()' using 'bins = {}'. "
-                "Pick better value with 'binwidth'."
+            bins = freedman_diaconis_bins(data["x"])
+            params["bins"] = bins
+            warn(
+                f"'stat_bindot' is using '{bins=}'. "
+                "Pick better value with 'binwidth'",
+                PlotnineWarning,
             )
-            warn(msg.format(params["bins"]), PlotnineWarning)
 
-        return params
-
-    @classmethod
-    def compute_panel(cls, data, scales, **params):
+    def compute_panel(self, data, scales):
+        params = self.params
         if (
             params["method"] == "dotdensity"
             and params["binpositions"] == "all"
@@ -160,10 +159,10 @@ class stat_bindot(stat):
             data["binwidth"] = newdata["binwidth"]
             data["weight"] = newdata["weight"]
             data["bincenter"] = newdata["bincenter"]
-        return super(cls, stat_bindot).compute_panel(data, scales, **params)
+        return super().compute_panel(data, scales)
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
+        params = self.params
         # Check that weights are whole numbers
         # (for dots, weights must be whole)
         weight = data.get("weight")
@@ -281,9 +280,7 @@ def densitybin(
     if all(pd.isna(x)):
         return pd.DataFrame()
 
-    if weight is None:
-        weight = np.ones(len(x))
-    weight = np.asarray(weight)
+    weight = np.ones(len(x)) if weight is None else np.array(list(weight))
     weight[np.isnan(weight)] = 0
 
     if rangee is None:

plotnine/stats/stat_boxplot.py

@@ -22,7 +22,7 @@ class stat_boxplot(stat):
 
     See Also
     --------
-    plotnine.geom_boxplot
+    plotnine.geom_boxplot: The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -91,10 +91,8 @@ class stat_boxplot(stat):
         if self.params["width"] is None:
             x = data.get("x", 0)
             self.params["width"] = resolution(x, False) * 0.75
-        return self.params
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         n = len(data)
         y = data["y"].to_numpy()
         if "weight" in data:
@@ -103,12 +101,14 @@ class stat_boxplot(stat):
         else:
             weights = None
             total_weight = len(y)
-        res = weighted_boxplot_stats(y, weights=weights, whis=params["coef"])
+        res = weighted_boxplot_stats(
+            y, weights=weights, whis=self.params["coef"]
+        )
 
         if len(np.unique(data["x"])) > 1:
             width = np.ptp(data["x"]) * 0.9
         else:
-            width = params["width"]
+            width = self.params["width"]
 
         if isinstance(data["x"].dtype, pd.CategoricalDtype):
             x = data["x"].iloc[0]

plotnine/stats/stat_count.py

@@ -23,6 +23,7 @@ class stat_count(stat):
 
     See Also
     --------
+    plotnine.geom_histogram : The default `geom` for this `stat`.
     plotnine.stat_bin
     """
 
@@ -49,21 +50,17 @@ class stat_count(stat):
     CREATES = {"count", "prop"}
 
     def setup_params(self, data):
-        params = self.params.copy()
-        if params["width"] is None:
-            params["width"] = resolution(data["x"], False) * 0.9
+        if self.params["width"] is None:
+            self.params["width"] = resolution(data["x"], False) * 0.9
 
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         x = data["x"]
-        if ("y" in data) or ("y" in params):
+        if ("y" in data) or ("y" in self.params):
             msg = "stat_count() must not be used with a y aesthetic"
             raise PlotnineError(msg)
 
         weight = data.get("weight", [1] * len(x))
-        width = params["width"]
+        width = self.params["width"]
         xdata_long = pd.DataFrame({"x": x, "weight": weight})
         # weighted frequency count
         count = xdata_long.pivot_table("weight", index=["x"], aggfunc="sum")[

plotnine/stats/stat_density.py

@@ -85,7 +85,7 @@ class stat_density(stat):
 
     See Also
     --------
-    plotnine.geom_density
+    plotnine.geom_density : The default `geom` for this `stat`.
     statsmodels.nonparametric.kde.KDEUnivariate
     statsmodels.nonparametric.kde.KDEUnivariate.fit
     """
@@ -102,9 +102,9 @@ class stat_density(stat):
                 # useful for stacked density plots
 
     'scaled'    # density estimate, scaled to maximum of 1
+    'n'         # Number of observations at a position
     ```
 
-        'n'         # Number of observations at a position
 
     """
     REQUIRED_AES = {"x"}
@@ -126,7 +126,7 @@ class stat_density(stat):
     CREATES = {"density", "count", "scaled", "n"}
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         lookup = {
             "biweight": "biw",
             "cosine": "cos",
@@ -148,21 +148,18 @@ class stat_density(stat):
             )
             raise PlotnineError(msg)
 
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         weight = data.get("weight")
 
-        if params["trim"]:
+        if self.params["trim"]:
             range_x = data["x"].min(), data["x"].max()
         else:
             range_x = scales.x.dimension()
 
-        return compute_density(data["x"], weight, range_x, **params)
+        return compute_density(data["x"], weight, range_x, self.params)
 
 
-def compute_density(x, weight, range, **params):
+def compute_density(x, weight, range, params):
     """
     Compute density
     """

plotnine/stats/stat_density_2d.py

@@ -1,12 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import numpy as np
 import pandas as pd
 
-from ..doctools import document
 from .density import get_var_type, kde
 from .stat import stat
 
+if TYPE_CHECKING:
+    from plotnine.typing import FloatArrayLike
+
 
-@document
 class stat_density_2d(stat):
     """
     Compute 2D kernel density estimation
@@ -32,6 +37,7 @@ class stat_density_2d(stat):
 
     See Also
     --------
+    plotnine.geom_density_2d : The default `geom` for this `stat`.
     statsmodels.nonparametric.kernel_density.KDEMultivariate
     scipy.stats.gaussian_kde
     sklearn.neighbors.KernelDensity
@@ -66,7 +72,7 @@ class stat_density_2d(stat):
     CREATES = {"y"}
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         if params["kde_params"] is None:
             params["kde_params"] = {}
 
@@ -78,10 +84,8 @@ class stat_density_2d(stat):
                 y_type = get_var_type(data["y"])
                 kde_params["var_type"] = f"{x_type}{y_type}"
 
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
+        params = self.params
         package = params["package"]
         kde_params = params["kde_params"]
 
@@ -118,7 +122,7 @@ class stat_density_2d(stat):
         return data
 
 
-def contour_lines(X, Y, Z, levels):
+def contour_lines(X, Y, Z, levels: int | FloatArrayLike):
     """
     Calculate contour lines
     """