plotnine 0.15.0.dev3__py3-none-any.whl → 0.15.2__py3-none-any.whl

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

plotnine/stats/stat_ecdf.py

@@ -25,7 +25,7 @@ class stat_ecdf(stat):
 
     See Also
     --------
-    plotnine.geom_step
+    plotnine.geom_step : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -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

@@ -37,6 +37,10 @@ class stat_ellipse(stat):
         The confidence level at which to draw the ellipse.
     segments : int, default=51
         Number of segments to be used in drawing the ellipse.
+
+    See Also
+    --------
+    plotnine.geom_path : The default `geom` for this `stat`.
     """
 
     REQUIRED_AES = {"x", "y"}
@@ -49,14 +53,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 +206,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

@@ -37,6 +37,10 @@ class stat_function(stat):
         then the `xlim` must be provided.
     args : Optional[tuple[Any] | dict[str, Any]], default=None
         Arguments to pass to `fun`.
+
+    See Also
+    --------
+    plotnine.geom_path : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -82,14 +86,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

@@ -26,6 +26,10 @@ class stat_hull(stat):
         Raised when Qhull encounters an error condition,
         such as geometrical degeneracy when options to resolve are
         not enabled.
+
+    See Also
+    --------
+    plotnine.geom_path : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -47,12 +51,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

@@ -12,10 +12,13 @@ class stat_identity(stat):
     Parameters
     ----------
     {common_parameters}
+
+    See Also
+    --------
+    plotnine.geom_point : The default `geom` for this `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

@@ -24,6 +24,7 @@ class stat_pointdensity(stat):
 
     See Also
     --------
+    plotnine.geom_density_2d : The default `geom` for this `stat`.
     statsmodels.nonparametric.kde.KDEMultivariate
     scipy.stats.gaussian_kde
     sklearn.neighbors.KernelDensity
@@ -51,7 +52,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 +64,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)