plotnine 0.15.0.dev3__py3-none-any.whl → 0.15.2__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
@@ -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

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

plotnine/stats/stat_unique.py

@@ -12,10 +12,13 @@ class stat_unique(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.drop_duplicates()

plotnine/stats/stat_ydensity.py

@@ -69,7 +69,7 @@ class stat_ydensity(stat):
 
     See Also
     --------
-    plotnine.geom_violin
+    plotnine.geom_violin : The default `geom` for this `stat`.
     statsmodels.nonparametric.kde.KDEUnivariate
     statsmodels.nonparametric.kde.KDEUnivariate.fit
     """
@@ -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/themes/elements/__init__.py

@@ -2,7 +2,7 @@ from .element_blank import element_blank
 from .element_line import element_line
 from .element_rect import element_rect
 from .element_text import element_text
-from .margin import margin
+from .margin import margin, margin_auto
 
 __all__ = (
     "element_blank",
@@ -10,4 +10,5 @@ __all__ = (
     "element_rect",
     "element_text",
     "margin",
+    "margin_auto",
 )

plotnine/themes/elements/element_line.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from .element_base import element_base
 
 if TYPE_CHECKING:
-    from typing import Any, Literal, Optional, Sequence
+    from typing import Any, Literal, Sequence
 
 
 class element_line(element_base):
@@ -26,6 +26,8 @@ class element_line(element_base):
         using tuples, see [](`~matplotlib.lines.line2D.set_linestyle`).
     size : float
         line thickness
+    alpha : float
+        Opacity value
     kwargs : dict
         Parameters recognised by [](`~matplotlib.lines.line2d`).
     """
@@ -33,31 +35,37 @@ class element_line(element_base):
     def __init__(
         self,
         *,
-        color: Optional[
+        color: (
             str
             | tuple[float, float, float]
             | tuple[float, float, float, float]
-        ] = None,
-        size: Optional[float] = None,
-        linetype: Optional[str | Sequence[int]] = None,
-        lineend: Optional[Literal["butt", "projecting", "round"]] = None,
-        colour: Optional[
+            | None
+        ) = None,
+        size: float | None = None,
+        linetype: str | Sequence[int] | None = None,
+        lineend: Literal["butt", "projecting", "round"] | None = None,
+        colour: (
             str
             | tuple[float, float, float]
             | tuple[float, float, float, float]
-        ] = None,
+            | None
+        ) = None,
+        alpha: float | None = None,
         **kwargs: Any,
     ):
         super().__init__()
         self.properties.update(**kwargs)
 
-        color = color if color else colour
+        color = color if color is not None else colour
+
         if color:
             self.properties["color"] = color
         if size:
             self.properties["linewidth"] = size
         if linetype:
             self.properties["linestyle"] = linetype
+        if alpha is not None:
+            self.properties["alpha"] = alpha
 
         if linetype in ("solid", "-") and lineend:
             self.properties["solid_capstyle"] = lineend