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

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

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)

plotnine/stats/stat_qq.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import numpy as np
 import pandas as pd
 
@@ -6,6 +10,11 @@ from ..exceptions import PlotnineError
 from ..mapping.evaluation import after_stat
 from .stat import stat
 
+if TYPE_CHECKING:
+    from typing import Any, Sequence
+
+    from plotnine.typing import FloatArray
+
 
 # Note: distribution should be a name from scipy.stat.distribution
 @document
@@ -65,25 +74,41 @@ class stat_qq(stat):
         "alpha_beta": (3 / 8, 3 / 8),
     }
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
-        from scipy.stats.mstats import plotting_positions
-
-        from .distributions import get_continuous_distribution
-
+    def compute_group(self, data, scales):
         sample = data["sample"].sort_values().to_numpy()
-        alpha, beta = params["alpha_beta"]
-        quantiles = params["quantiles"]
-
-        if quantiles is None:
-            quantiles = plotting_positions(sample, alpha, beta)
-        elif len(quantiles) != len(sample):
-            raise PlotnineError(
-                "The number of quantile values is not the same as "
-                "the number of sample values."
-            )
-
-        quantiles = np.asarray(quantiles)
-        cdist = get_continuous_distribution(params["distribution"])
-        theoretical = cdist.ppf(quantiles, **params["dparams"])
+        theoretical = theoretical_qq(
+            sample,
+            self.params["distribution"],
+            alpha=self.params["alpha_beta"][0],
+            beta=self.params["alpha_beta"][1],
+            quantiles=self.params["quantiles"],
+            distribution_params=self.params["dparams"],
+        )
         return pd.DataFrame({"sample": sample, "theoretical": theoretical})
+
+
+def theoretical_qq(
+    x: FloatArray,
+    distribution: str,
+    alpha: float,
+    beta: float,
+    quantiles: Sequence[float] | None,
+    distribution_params: dict[str, Any],
+) -> FloatArray:
+    """
+    Caculate theoretical qq distribution
+    """
+    from scipy.stats.mstats import plotting_positions
+
+    from .distributions import get_continuous_distribution
+
+    if quantiles is None:
+        quantiles = plotting_positions(x, alpha, beta)
+    elif len(quantiles) != len(x):
+        raise PlotnineError(
+            "The number of quantile values is not the same as "
+            "the number of sample values."
+        )
+
+    cdist = get_continuous_distribution(distribution)
+    return cdist.ppf(np.asarray(quantiles), **distribution_params)

plotnine/stats/stat_qq_line.py

@@ -4,7 +4,7 @@ import pandas as pd
 from ..doctools import document
 from ..exceptions import PlotnineError
 from .stat import stat
-from .stat_qq import stat_qq
+from .stat_qq import theoretical_qq
 
 
 @document
@@ -64,31 +64,35 @@ class stat_qq_line(stat):
             raise PlotnineError(
                 "Cannot fit line quantiles. 'line_p' must be of length 2"
             )
-        return self.params
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         from scipy.stats.mstats import mquantiles
 
         from .distributions import get_continuous_distribution
 
-        line_p = params["line_p"]
-        dparams = params["dparams"]
+        line_p = self.params["line_p"]
+        dparams = self.params["dparams"]
 
         # Compute theoretical values
-        qq_gdata = stat_qq.compute_group(data, scales, **params)
-        sample = qq_gdata["sample"].to_numpy()
-        theoretical = qq_gdata["theoretical"].to_numpy()
+        sample = data["sample"].sort_values().to_numpy()
+        theoretical = theoretical_qq(
+            sample,
+            self.params["distribution"],
+            alpha=self.params["alpha_beta"][0],
+            beta=self.params["alpha_beta"][1],
+            quantiles=self.params["quantiles"],
+            distribution_params=dparams,
+        )
 
         # Compute slope & intercept of the line through the quantiles
-        cdist = get_continuous_distribution(params["distribution"])
+        cdist = get_continuous_distribution(self.params["distribution"])
         x_coords = cdist.ppf(line_p, **dparams)
         y_coords = mquantiles(sample, line_p)
         slope = (np.diff(y_coords) / np.diff(x_coords))[0]
         intercept = y_coords[0] - slope * x_coords[0]
 
         # Get x,y points that describe the line
-        if params["fullrange"] and scales.x:
+        if self.params["fullrange"] and scales.x:
             x = scales.x.dimension()
         else:
             x = theoretical.min(), theoretical.max()

plotnine/stats/stat_quantile.py

@@ -59,7 +59,7 @@ class stat_quantile(stat):
     CREATES = {"quantile", "group"}
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         if params["formula"] is None:
             params["formula"] = "y ~ x"
             warn("Formula not specified, using '{}'", PlotnineWarning)
@@ -68,15 +68,14 @@ class stat_quantile(stat):
         except TypeError:
             params["quantiles"] = (params["quantiles"],)
 
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
-        res = [quant_pred(q, data, **params) for q in params["quantiles"]]
+    def compute_group(self, data, scales):
+        res = [
+            quant_pred(q, data, self.params) for q in self.params["quantiles"]
+        ]
         return pd.concat(res, axis=0, ignore_index=True)
 
 
-def quant_pred(q, data, **params):
+def quant_pred(q, data, params):
     """
     Quantile precitions
     """

plotnine/stats/stat_sina.py

@@ -116,7 +116,7 @@ class stat_sina(stat):
         return data
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         random_state = params["random_state"]
 
         if params["maxwidth"] is None:
@@ -137,10 +137,9 @@ class stat_sina(stat):
         params["clip"] = (-np.inf, np.inf)
         params["bounds"] = (-np.inf, np.inf)
         params["n"] = 512
-        return params
 
-    @classmethod
-    def compute_panel(cls, data, scales, **params):
+    def compute_panel(self, data, scales):
+        params = self.params
         maxwidth = params["maxwidth"]
         random_state = params["random_state"]
         fuzz = 1e-8
@@ -154,7 +153,7 @@ class stat_sina(stat):
         else:
             params["bins"] = breaks_from_bins(y_dim_fuzzed, params["bins"])
 
-        data = super(cls, stat_sina).compute_panel(data, scales, **params)
+        data = super().compute_panel(data, scales)
 
         if not len(data):
             return data
@@ -198,11 +197,10 @@ class stat_sina(stat):
 
         return data
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
-        maxwidth = params["maxwidth"]
-        bins = params["bins"]
-        bin_limit = params["bin_limit"]
+    def compute_group(self, data, scales):
+        maxwidth = self.params["maxwidth"]
+        bins = self.params["bins"]
+        bin_limit = self.params["bin_limit"]
         weight = None
         y = data["y"]
 
@@ -215,12 +213,12 @@ class stat_sina(stat):
         elif len(np.unique(y)) < 2:
             data["density"] = 1
             data["scaled"] = 1
-        elif params["method"] == "density":
+        elif self.params["method"] == "density":
             from scipy.interpolate import interp1d
 
             # density kernel estimation
             range_y = y.min(), y.max()
-            dens = compute_density(y, weight, range_y, **params)
+            dens = compute_density(y, weight, range_y, self.params)
             densf = interp1d(
                 dens["x"],
                 dens["density"],
@@ -253,9 +251,9 @@ class stat_sina(stat):
 
         return data
 
-    def finish_layer(self, data, params):
+    def finish_layer(self, data):
         # Rescale x in case positions have been adjusted
-        style = params["style"]
+        style = self.params["style"]
         x_mean = data["x"].to_numpy()
         x_mod = (data["xmax"] - data["xmin"]) / data["width"]
         data["x"] = data["x"] + data["x_diff"] * x_mod

plotnine/stats/stat_smooth.py

@@ -37,7 +37,7 @@ class stat_smooth(stat):
         If a `callable` is passed, it must have the signature:
 
         ```python
-        def my_smoother(data, xseq, **params):
+        def my_smoother(data, xseq, params):
             # * data - has the x and y values for the model
             # * xseq - x values to be predicted
             # * params - stat parameters
@@ -163,7 +163,7 @@ class stat_smooth(stat):
         return data
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
         # Use loess/lowess for small datasets
         # and glm for large
         if params["method"] == "auto":
@@ -202,12 +202,9 @@ class stat_smooth(stat):
                 )
             params["environment"] = self.environment
 
-        return params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         data = data.sort_values("x")
-        n = params["n"]
+        n = self.params["n"]
 
         x_unique = data["x"].unique()
 
@@ -223,15 +220,15 @@ class stat_smooth(stat):
             return pd.DataFrame()
 
         if data["x"].dtype.kind == "i":
-            if params["fullrange"]:
+            if self.params["fullrange"]:
                 xseq = scales.x.dimension()
             else:
                 xseq = np.sort(x_unique)
         else:
-            if params["fullrange"]:
+            if self.params["fullrange"]:
                 rangee = scales.x.dimension()
             else:
                 rangee = [data["x"].min(), data["x"].max()]
             xseq = np.linspace(rangee[0], rangee[1], n)
 
-        return predictdf(data, xseq, **params)
+        return predictdf(data, xseq, self.params)

plotnine/stats/stat_sum.py

@@ -35,8 +35,7 @@ class stat_sum(stat):
     DEFAULT_AES = {"size": after_stat("n"), "weight": 1}
     CREATES = {"n", "prop"}
 
-    @classmethod
-    def compute_panel(cls, data, scales, **params):
+    def compute_panel(self, data, scales):
         if "weight" not in data:
             data["weight"] = 1
 

plotnine/stats/stat_summary.py

@@ -299,16 +299,13 @@ class stat_summary(stat):
 
             self.params["fun_args"]["random_state"] = random_state
 
-        return self.params
-
-    @classmethod
-    def compute_panel(cls, data, scales, **params):
+    def compute_panel(self, data, scales):
         func = make_summary_fun(
-            params["fun_data"],
-            params["fun_y"],
-            params["fun_ymin"],
-            params["fun_ymax"],
-            params["fun_args"],
+            self.params["fun_data"],
+            self.params["fun_y"],
+            self.params["fun_ymin"],
+            self.params["fun_ymax"],
+            self.params["fun_args"],
         )
 
         # break a dataframe into pieces, summarise each piece,