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

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)

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
@@ -38,6 +47,7 @@ class stat_qq(stat):
 
     See Also
     --------
+    plotnine.geom_qq : The default `geom` for this `stat`.
     scipy.stats.mstats.plotting_positions : Uses `alpha_beta`
         to calculate the quantiles.
     """
@@ -65,25 +75,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
@@ -41,6 +41,7 @@ class stat_qq_line(stat):
 
     See Also
     --------
+    plotnine.geom_qq_line : The default `geom` for this `stat`.
     scipy.stats.mstats.plotting_positions : Uses `alpha_beta`
         to calculate the quantiles.
     """
@@ -64,31 +65,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

@@ -29,8 +29,8 @@ class stat_quantile(stat):
 
     See Also
     --------
+    plotnine.geom_quantile : The default `geom` for this `stat`.
     statsmodels.regression.quantile_regression.QuantReg
-    plotnine.geom_quantile
     """
 
     _aesthetics_doc = """
@@ -59,30 +59,36 @@ 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)
+        else:
+            params["eval_env"] = self.environment.to_patsy_env()
+
         try:
             iter(params["quantiles"])
         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
     """
     import statsmodels.formula.api as smf
 
-    mod = smf.quantreg(params["formula"], data)
+    mod = smf.quantreg(
+        params["formula"],
+        data,
+        eval_env=params.get("eval_env"),
+    )
     reg_res = mod.fit(q=q, **params["method_args"])
     out = pd.DataFrame(
         {

plotnine/stats/stat_sina.py

@@ -57,10 +57,19 @@ class stat_sina(stat):
         - `area` - Scale by the largest density/bin among the different sinas
         - `count` - areas are scaled proportionally to the number of points
         - `width` - Only scale according to the maxwidth parameter.
+    style :
+        Type of sina plot to draw. The options are
+        ```python
+        'full'        # Regular (2 sided)
+        'left'        # Left-sided half
+        'right'       # Right-sided half
+        'left-right'  # Alternate (left first) half by the group
+        'right-left'  # Alternate (right first) half by the group
+        ```
 
     See Also
     --------
-    plotnine.geom_sina
+    plotnine.geom_sina : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -91,6 +100,7 @@ class stat_sina(stat):
         "bin_limit": 1,
         "random_state": None,
         "scale": "area",
+        "style": "full",
     }
     CREATES = {"scaled"}
 
@@ -106,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:
@@ -127,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
@@ -144,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
@@ -188,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"]
 
@@ -205,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"],
@@ -243,8 +251,31 @@ 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 = 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
+        x = data["x"].to_numpy()
+        even = data["group"].to_numpy() % 2 == 0
+
+        def mirror_x(bool_idx):
+            """
+            Mirror x locations along the mean value
+            """
+            data.loc[bool_idx, "x"] = (
+                2 * x_mean[bool_idx] - data.loc[bool_idx, "x"]
+            )
+
+        match style:
+            case "left":
+                mirror_x(x_mean < x)
+            case "right":
+                mirror_x(x < x_mean)
+            case "left-right":
+                mirror_x(even & (x < x_mean) | ~even & (x_mean < x))
+            case "right-left":
+                mirror_x(even & (x_mean < x) | ~even & (x < x_mean))
+
         return data

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
@@ -106,6 +106,7 @@ class stat_smooth(stat):
 
     See Also
     --------
+    plotnine.geom_smooth : The default `geom` for this `stat`.
     statsmodels.regression.linear_model.OLS
     statsmodels.regression.linear_model.WLS
     statsmodels.robust.robust_linear_model.RLM
@@ -163,7 +164,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 +203,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 +221,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

@@ -17,6 +17,10 @@ class stat_sum(stat):
     Parameters
     ----------
     {common_parameters}
+
+    See Also
+    --------
+    plotnine.geom_point : The default `geom` for this `stat`.
     """
 
     _aesthetics_doc = """
@@ -35,8 +39,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

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

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