plotnine 0.15.0a2__py3-none-any.whl → 0.15.0a3__py3-none-any.whl

plotnine/stats/smoothers.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     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 +49,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,7 +96,7 @@ 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
     """
@@ -140,14 +140,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,7 +170,7 @@ 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
     """
@@ -196,14 +196,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,7 +227,7 @@ 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
     """
@@ -258,14 +258,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,7 +292,7 @@ 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
     """
@@ -321,7 +321,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 +351,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 +402,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 +426,7 @@ def mavg(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gpr(data, xseq, **params):
+def gpr(data, xseq, params):
     """
     Fit gaussian process
     """

plotnine/stats/stat.py

@@ -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,7 +332,7 @@ 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)
@@ -365,9 +356,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,7 +380,7 @@ 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, other: ggplot) -> ggplot:
         """

plotnine/stats/stat_bin.py

@@ -100,7 +100,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 +107,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

@@ -66,18 +66,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

@@ -113,7 +113,6 @@ 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 = {}'. "
@@ -121,10 +120,8 @@ class stat_bindot(stat):
             )
             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 +157,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")

plotnine/stats/stat_boxplot.py

@@ -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

@@ -49,21 +49,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

@@ -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
@@ -66,7 +71,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 +83,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 +121,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
     """
@@ -152,7 +155,7 @@ def contour_lines(X, Y, Z, levels):
     level_values = []
     start_pid = 1
     for level in levels:
-        vertices, *_ = cgen.create_contour(level)
+        vertices, *_ = cgen.create_contour(level)  # pyright: ignore[reportArgumentType]
         for pid, piece in enumerate(vertices, start=start_pid):
             n = len(piece)  # pyright: ignore
             segments.append(piece)

plotnine/stats/stat_ecdf.py

@@ -50,17 +50,18 @@ class stat_ecdf(stat):
     DEFAULT_AES = {"y": after_stat("ecdf")}
     CREATES = {"ecdf"}
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         from statsmodels.distributions.empirical_distribution import ECDF
 
+        n, pad = self.params["n"], self.params["pad"]
+
         # If n is None, use raw values; otherwise interpolate
-        if params["n"] is None:
+        if n is None:
             x = np.unique(data["x"])
         else:
-            x = np.linspace(data["x"].min(), data["x"].max(), params["n"])
+            x = np.linspace(data["x"].min(), data["x"].max(), n)
 
-        if params["pad"]:
+        if pad:
             x = np.hstack([-np.inf, x, np.inf])
 
         ecdf = ECDF(data["x"].to_numpy())(x)

plotnine/stats/stat_ellipse.py

@@ -49,14 +49,13 @@ class stat_ellipse(stat):
         "segments": 51,
     }
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         import scipy.stats as stats
         from scipy import linalg
 
-        level = params["level"]
-        segments = params["segments"]
-        type_ = params["type"]
+        level = self.params["level"]
+        segments = self.params["segments"]
+        type_ = self.params["type"]
 
         dfn = 2
         dfd = len(data) - 1
@@ -203,7 +202,7 @@ def cov_trob(
         wt = wt[wt > 0]
         n, _ = x.shape
 
-    wt = wt[:, np.newaxis]
+    wt = wt[:, np.newaxis]  # pyright: ignore[reportCallIssue,reportArgumentType,reportOptionalSubscript]
 
     # loc
     use_loc = False

plotnine/stats/stat_function.py

@@ -82,14 +82,12 @@ class stat_function(stat):
                 "stat_function requires parameter 'fun' to be "
                 "a function or any other callable object"
             )
-        return self.params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
-        old_fun: Callable[..., FloatArrayLike] = params["fun"]
-        n = params["n"]
-        args = params["args"]
-        xlim = params["xlim"]
+
+    def compute_group(self, data, scales):
+        old_fun: Callable[..., FloatArrayLike] = self.params["fun"]
+        n = self.params["n"]
+        args = self.params["args"]
+        xlim = self.params["xlim"]
         range_x = xlim or scales.x.dimension((0, 0))
 
         if isinstance(args, (list, tuple)):

plotnine/stats/stat_hull.py

@@ -47,12 +47,11 @@ class stat_hull(stat):
     }
     CREATES = {"area"}
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         from scipy.spatial import ConvexHull
 
         hull = ConvexHull(
-            data[["x", "y"]], qhull_options=params["qhull_options"]
+            data[["x", "y"]], qhull_options=self.params["qhull_options"]
         )
         idx = np.hstack([hull.vertices, hull.vertices[0]])
 

plotnine/stats/stat_identity.py

@@ -16,6 +16,5 @@ class stat_identity(stat):
 
     DEFAULT_PARAMS = {"geom": "point", "position": "identity", "na_rm": False}
 
-    @classmethod
-    def compute_panel(cls, data, scales, **params):
+    def compute_panel(self, data, scales):
         return data

plotnine/stats/stat_pointdensity.py

@@ -51,7 +51,7 @@ class stat_pointdensity(stat):
     CREATES = {"density"}
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         if params["kde_params"] is None:
             params["kde_params"] = {}
 
@@ -63,12 +63,9 @@ class stat_pointdensity(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):
-        package = params["package"]
-        kde_params = params["kde_params"]
+    def compute_group(self, data, scales):
+        package = self.params["package"]
+        kde_params = self.params["kde_params"]
 
         var_data = np.array([data["x"].to_numpy(), data["y"].to_numpy()]).T
         density = kde(var_data, var_data, package, **kde_params)