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

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,

plotnine/stats/stat_summary_bin.py

@@ -123,21 +123,18 @@ class stat_summary_bin(stat):
 
             self.params["fun_args"]["random_state"] = random_state
 
-        return self.params
-
-    @classmethod
-    def compute_group(cls, data, scales, **params):
-        bins = params["bins"]
-        breaks = params["breaks"]
-        binwidth = params["binwidth"]
-        boundary = params["boundary"]
+    def compute_group(self, data, scales):
+        bins = self.params["bins"]
+        breaks = self.params["breaks"]
+        binwidth = self.params["binwidth"]
+        boundary = self.params["boundary"]
 
         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"],
         )
 
         breaks = fuzzybreaks(scales.x, breaks, boundary, binwidth, bins)

plotnine/stats/stat_unique.py

@@ -16,6 +16,5 @@ class stat_unique(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.drop_duplicates()

plotnine/stats/stat_ydensity.py

@@ -109,7 +109,7 @@ class stat_ydensity(stat):
         return data
 
     def setup_params(self, data):
-        params = self.params.copy()
+        params = self.params
 
         valid_scale = ("area", "count", "width")
         if params["scale"] not in valid_scale:
@@ -141,11 +141,9 @@ class stat_ydensity(stat):
         for key in missing_params:
             params[key] = stat_density.DEFAULT_PARAMS[key]
 
-        return params
-
-    @classmethod
-    def compute_panel(cls, data, scales, **params):
-        data = super(cls, cls).compute_panel(data, scales, **params)
+    def compute_panel(self, data, scales):
+        params = self.params
+        data = super().compute_panel(data, scales)
 
         if not len(data):
             return data
@@ -167,20 +165,19 @@ class stat_ydensity(stat):
 
         return data
 
-    @classmethod
-    def compute_group(cls, data, scales, **params):
+    def compute_group(self, data, scales):
         n = len(data)
         if n == 0:
             return pd.DataFrame()
 
         weight = data.get("weight")
 
-        if params["trim"]:
+        if self.params["trim"]:
             range_y = data["y"].min(), data["y"].max()
         else:
             range_y = scales.y.dimension()
 
-        dens = compute_density(data["y"], weight, range_y, **params)
+        dens = compute_density(data["y"], weight, range_y, self.params)
 
         if not len(dens):
             return dens

{plotnine-0.15.0a2.dist-info → plotnine-0.15.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotnine
-Version: 0.15.0a2
+Version: 0.15.0a3
 Summary: A Grammar of Graphics for Python
 Author-email: Hassan Kibirige <has2k1@gmail.com>
 License: The MIT License (MIT)
@@ -46,7 +46,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: pandas>=2.2.0
-Requires-Dist: mizani~=0.13.0
+Requires-Dist: mizani~=0.14.0
 Requires-Dist: numpy>=1.23.5
 Requires-Dist: scipy>=1.8.0
 Requires-Dist: statsmodels>=0.14.0
@@ -82,7 +82,7 @@ Requires-Dist: twine; extra == "dev"
 Requires-Dist: plotnine[typing]; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Provides-Extra: typing
-Requires-Dist: pyright==1.1.400; extra == "typing"
+Requires-Dist: pyright==1.1.402; extra == "typing"
 Requires-Dist: ipython; extra == "typing"
 Requires-Dist: pandas-stubs; extra == "typing"
 Dynamic: license-file