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

plotnine/mapping/aes.py

@@ -8,7 +8,9 @@ from dataclasses import fields
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, Dict
 
+import numpy as np
 import pandas as pd
+from mizani._colors.utils import is_color_tuple
 
 from ..iapi import labels_view
 from .evaluation import after_stat, stage
@@ -538,23 +540,23 @@ def make_labels(mapping: dict[str, Any] | aes) -> labels_view:
     )
 
 
-def is_valid_aesthetic(value: Any, ae: str) -> bool:
+class RepeatAesthetic:
     """
-    Return True if `value` looks valid.
+    Repeat an Aeshetic a given number of times
 
-    Parameters
-    ----------
-    value :
-        Value to check
-    ae :
-        Aesthetic name
+    The methods in this class know how to create sequences of aesthetics
+    whose values may not be scalar.
 
-    Notes
-    -----
-    There are no guarantees that he value is spot on
-    valid.
+    Some aesthetics may have valid values that are not scalar. e.g.
+    sequences. Inserting one of such a value in a dataframe as a column
+    would either lead to the wrong input or fail. The s
     """
-    if ae == "linetype":
+
+    @staticmethod
+    def linetype(value: Any, n: int) -> Sequence[Any]:
+        """
+        Repeat linetypes
+        """
         named = {
             "solid",
             "dashed",
@@ -569,47 +571,75 @@ def is_valid_aesthetic(value: Any, ae: str) -> bool:
             "",
         }
         if value in named:
-            return True
+            return [value] * n
 
         # tuple of the form (offset, (on, off, on, off, ...))
         # e.g (0, (1, 2))
-        conditions = [
-            isinstance(value, tuple),
-            isinstance(value[0], int),
-            isinstance(value[1], tuple),
-            len(value[1]) % 2 == 0,
-            all(isinstance(x, int) for x in value[1]),
-        ]
-        return all(conditions)
-
-    elif ae == "shape":
+        if (
+            isinstance(value, tuple)
+            and isinstance(value[0], int)
+            and isinstance(value[1], tuple)
+            and len(value[1]) % 2 == 0
+            and all(isinstance(x, int) for x in value[1])
+        ):
+            return [value] * n
+
+        raise ValueError(f"{value} is not a known linetype.")
+
+    @staticmethod
+    def color(value: Any, n: int) -> Sequence[Any]:
+        """
+        Repeat colors
+        """
         if isinstance(value, str):
-            return True
+            return [value] * n
+        if is_color_tuple(value):
+            return [tuple(value)] * n
+
+        raise ValueError(f"{value} is not a known color.")
+
+    fill = color
 
+    @staticmethod
+    def shape(value: Any, n: int) -> Any:
+        """
+        Repeat shapes
+        """
+        if isinstance(value, str):
+            return [value] * n
         # tuple of the form (numsides, style, angle)
         # where style is in the range [0, 3]
         # e.g (4, 1, 45)
-        conditions = [
-            isinstance(value, tuple),
-            all(isinstance(x, int) for x in value),
-            0 <= value[1] < 3,
-        ]
-        return all(conditions)
-
-    elif ae in {"color", "fill"}:
-        if isinstance(value, str):
-            return True
-        with suppress(TypeError):
-            if isinstance(value, (tuple, list)) and all(
-                0 <= x <= 1 for x in value
-            ):
-                return True
-        return False
+        if (
+            isinstance(value, tuple)
+            and all(isinstance(x, int) for x in value)
+            and 0 <= value[1] < 3
+        ):
+            return [value] * n
+
+        if is_shape_points(value):
+            return [tuple(value)] * n
+
+        raise ValueError(f"{value} is not a know shape.")
 
-    # For any other aesthetics we return False to allow
-    # for special cases to be discovered and then coded
-    # for appropriately.
-    return False
+
+def is_shape_points(obj: Any) -> bool:
+    """
+    Return True if obj is like Sequence[tuple[float, float]]
+    """
+
+    def is_numeric(obj) -> bool:
+        """
+        Return True if obj is a python or numpy float or integer
+        """
+        return isinstance(obj, (float, int, np.floating, np.integer))
+
+    if not iter(obj):
+        return False
+    try:
+        return all(is_numeric(a) and is_numeric(b) for a, b in obj)
+    except TypeError:
+        return False
 
 
 def has_groups(data: pd.DataFrame) -> bool:

plotnine/scales/scale_color.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import KW_ONLY, InitVar, dataclass
+from dataclasses import KW_ONLY, InitVar, dataclass, field
 from typing import Literal, Sequence
 from warnings import warn
 
@@ -50,34 +50,66 @@ class scale_color_hue(_scale_color_discrete):
     Qualitative color scale with evenly spaced hues
     """
 
-    h: InitVar[float] = 0.01
+    h: InitVar[float | tuple[float, float]] = 15
     """
-    Hue. Must be in the range [0, 1]
+    Hue. If a float, it is the first hue value, in the range `[0, 360]`.
+    The range of the palette will be `[first, first + 360)`.
+
+    If a tuple, it is the range `[first, last)` of the hues.
     """
 
-    l: InitVar[float] = 0.6
+    c: InitVar[float] = 100
     """
-    Lightness. Must be in the range [0, 1]
+    Chroma. Must be in the range `[0, 100]`
     """
 
-    s: InitVar[float] = 0.65
+    l: InitVar[float] = 65
     """
-    Saturation. Must be in the range [0, 1]
+    Lightness. Must be in the range [0, 100]
     """
 
-    color_space: InitVar[Literal["hls", "hsluv"]] = "hls"
+    direction: InitVar[Literal[1, -1]] = 1
     """
-    Color space to use. Should be one of
-    [hls](https://en.wikipedia.org/wiki/HSL_and_HSV)
-    or [hsluv](https://www.hsluv.org/).
-    https://www.hsluv.org/
+    The order of colours in the scale. If -1 the order
+    of colours is reversed. The default is 1.
     """
 
-    def __post_init__(self, h, l, s, color_space):
+    _: KW_ONLY
+
+    s: None = field(default=None, repr=False)
+    """
+    Not being use and will be removed in a future version
+    """
+    color_space: None = field(default=None, repr=False)
+    """
+    Not being use and will be removed in a future version
+    """
+
+    def __post_init__(self, h, c, l, direction):
         from mizani.palettes import hue_pal
 
+        if (s := self.s) is not None:
+            warn(
+                f"You used {s=} for the saturation which has been ignored. "
+                f"{self.__class__.__name__} now works in HCL colorspace. "
+                f"Using `s` in future versions will throw an exception.",
+                FutureWarning,
+            )
+            del self.s
+
+        if (color_space := self.color_space) is not None:
+            warn(
+                f"You used {color_space=} to select a color_space and it "
+                f"has been ignored. {self.__class__.__name__} now only works "
+                f"in HCL colorspace. Using `color_space` in future versions "
+                "will throw an exception.",
+                FutureWarning,
+            )
+            del self.color_space
+
         super().__post_init__()
-        self.palette = hue_pal(h, l, s, color_space=color_space)
+        self.palette = hue_pal(h, c, l, direction)
+        self.palette.h
 
 
 @dataclass

plotnine/scales/scale_continuous.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from contextlib import suppress
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Sequence
+from typing import TYPE_CHECKING, Sequence, cast
 from warnings import warn
 
 import numpy as np
@@ -387,14 +387,15 @@ class scale_continuous(
             limits = self.final_limits
 
         x = self.oob(self.rescaler(x, _from=limits))
+        na_value = cast("float", self.na_value)
 
         uniq = np.unique(x)
         pal = np.asarray(self.palette(uniq))
         scaled = pal[match(x, uniq)]
         if scaled.dtype.kind == "U":
-            scaled = [self.na_value if x == "nan" else x for x in scaled]
+            scaled = [na_value if x == "nan" else x for x in scaled]
         else:
-            scaled[pd.isna(scaled)] = self.na_value
+            scaled[pd.isna(scaled)] = na_value
         return scaled
 
     def get_breaks(

plotnine/scales/scale_datetime.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import KW_ONLY, InitVar, dataclass
 from typing import TYPE_CHECKING
+from warnings import warn
 
 from ._runtime_typing import TransUser  # noqa: TCH001
 from .scale_continuous import scale_continuous
@@ -20,24 +21,21 @@ class scale_datetime(scale_continuous):
     """
     A string giving the distance between major breaks.
     For example `'2 weeks'`, `'5 years'`. If specified,
-    `date_breaks` takes precedence over
-    `breaks`.
+    `date_breaks` takes precedence over `breaks`.
     """
 
     date_labels: InitVar[str | None] = None
     """
     Format string for the labels.
     See [strftime](:ref:`strftime-strptime-behavior`).
-    If specified, `date_labels` takes precedence over
-    `labels`.
+    If specified, `date_labels` takes precedence over `labels`.
     """
 
     date_minor_breaks: InitVar[str | None] = None
     """
     A string giving the distance between minor breaks.
     For example `'2 weeks'`, `'5 years'`. If specified,
-    `date_minor_breaks` takes precedence over
-    `minor_breaks`.
+    `date_minor_breaks` takes precedence over `minor_breaks`.
     """
 
     _: KW_ONLY
@@ -80,22 +78,38 @@ class scale_datetime(scale_continuous):
         date_labels: str | None,
         date_minor_breaks: str | None,
     ):
-        from mizani.breaks import breaks_date as breaks_func
-        from mizani.labels import label_date as labels_func
+        from mizani.breaks import breaks_date_width
+        from mizani.labels import label_date
 
         if date_breaks is not None:
-            self.breaks = breaks_func(date_breaks)  # pyright: ignore
+            self.breaks = breaks_date_width(date_breaks)  # pyright: ignore[reportAttributeAccessIssue]
         elif isinstance(self.breaks, str):
-            self.breaks = breaks_func(width=self.breaks)  # pyright: ignore
+            warn(
+                "Passing a string to `breaks` will not work in "
+                f"future versions. Use `date_breaks={self.breaks!r}`",
+                FutureWarning,
+            )
+            self.breaks = breaks_date_width(width=self.breaks)  # pyright: ignore[reportAttributeAccessIssue]
 
         if date_labels is not None:
-            self.labels = labels_func(date_labels)  # pyright: ignore
+            self.labels = label_date(fmt=date_labels)  # pyright: ignore[reportAttributeAccessIssue]
         elif isinstance(self.labels, str):
-            self.labels = labels_func(width=self.labels)  # pyright: ignore
+            warn(
+                "Passing a string to `labels` will not work in "
+                f"future versions. Use `date_labels={self.labels!r}`",
+                FutureWarning,
+            )
+            self.labels = label_date(fmt=self.labels)  # pyright: ignore[reportAttributeAccessIssue]
 
         if date_minor_breaks is not None:
-            self.minor_breaks = breaks_func(date_minor_breaks)  # pyright: ignore
+            self.minor_breaks = breaks_date_width(date_minor_breaks)  # pyright: ignore[reportAttributeAccessIssue]
         elif isinstance(self.minor_breaks, str):
-            self.minor_breaks = breaks_func(width=self.minor_breaks)  # pyright: ignore
+            warn(
+                "Passing a string to `minor_breaks` will not work in "
+                "future versions. "
+                f"Use `date_minor_breaks={self.minor_breaks!r}`",
+                FutureWarning,
+            )
+            self.minor_breaks = breaks_date_width(width=self.minor_breaks)  # pyright: ignore[reportAttributeAccessIssue]
 
         scale_continuous.__post_init__(self)

plotnine/scales/scale_discrete.py

@@ -156,7 +156,7 @@ class scale_discrete(
             range = self.dimension(limits=limits)
 
         breaks_d = self.get_breaks(limits)
-        breaks = self.map(pd.Categorical(breaks_d))
+        breaks = self.map(pd.Categorical(breaks_d))  # pyright: ignore[reportArgumentType]
         minor_breaks = []
         labels = self.get_labels(breaks_d)
 

plotnine/scales/scale_xy.py

@@ -213,7 +213,7 @@ class scale_x_discrete(scale_position_discrete):
     Discrete x position
     """
 
-    _aesthetics = ["x", "xmin", "xmax", "xend"]
+    _aesthetics = ["x", "xmin", "xmax", "xend", "xintercept"]
 
 
 @dataclass(kw_only=True)
@@ -222,7 +222,7 @@ class scale_y_discrete(scale_position_discrete):
     Discrete y position
     """
 
-    _aesthetics = ["y", "ymin", "ymax", "yend"]
+    _aesthetics = ["y", "ymin", "ymax", "yend", "yintercept"]
 
 
 # Not part of the user API

plotnine/stats/smoothers.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from plotnine.mapping import Environment
 
 
-def predictdf(data, xseq, **params) -> pd.DataFrame:
+def predictdf(data, xseq, params) -> pd.DataFrame:
     """
     Make prediction on the data
 
@@ -49,21 +49,21 @@ def predictdf(data, xseq, **params) -> pd.DataFrame:
     if not callable(method):
         msg = (
             "'method' should either be a string or a function"
-            "with the signature `func(data, xseq, **params)`"
+            "with the signature `func(data, xseq, params)`"
         )
         raise PlotnineError(msg)
 
-    return method(data, xseq, **params)
+    return method(data, xseq, params)
 
 
-def lm(data, xseq, **params) -> pd.DataFrame:
+def lm(data, xseq, params) -> pd.DataFrame:
     """
     Fit OLS / WLS if data has weight
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return lm_formula(data, xseq, **params)
+        return lm_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -96,7 +96,7 @@ def lm(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def lm_formula(data, xseq, **params) -> pd.DataFrame:
+def lm_formula(data, xseq, params) -> pd.DataFrame:
     """
     Fit OLS / WLS using a formula
     """
@@ -140,14 +140,14 @@ def lm_formula(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def rlm(data, xseq, **params) -> pd.DataFrame:
+def rlm(data, xseq, params) -> pd.DataFrame:
     """
     Fit RLM
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return rlm_formula(data, xseq, **params)
+        return rlm_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -170,7 +170,7 @@ def rlm(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def rlm_formula(data, xseq, **params) -> pd.DataFrame:
+def rlm_formula(data, xseq, params) -> pd.DataFrame:
     """
     Fit RLM using a formula
     """
@@ -196,14 +196,14 @@ def rlm_formula(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gls(data, xseq, **params) -> pd.DataFrame:
+def gls(data, xseq, params) -> pd.DataFrame:
     """
     Fit GLS
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return gls_formula(data, xseq, **params)
+        return gls_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -227,7 +227,7 @@ def gls(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gls_formula(data, xseq, **params):
+def gls_formula(data, xseq, params):
     """
     Fit GLL using a formula
     """
@@ -258,14 +258,14 @@ def gls_formula(data, xseq, **params):
     return data
 
 
-def glm(data, xseq, **params) -> pd.DataFrame:
+def glm(data, xseq, params) -> pd.DataFrame:
     """
     Fit GLM
     """
     import statsmodels.api as sm
 
     if params["formula"]:
-        return glm_formula(data, xseq, **params)
+        return glm_formula(data, xseq, params)
 
     X = sm.add_constant(data["x"])
     Xseq = sm.add_constant(xseq)
@@ -292,7 +292,7 @@ def glm(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def glm_formula(data, xseq, **params):
+def glm_formula(data, xseq, params):
     """
     Fit with GLM formula
     """
@@ -321,7 +321,7 @@ def glm_formula(data, xseq, **params):
     return data
 
 
-def lowess(data, xseq, **params) -> pd.DataFrame:
+def lowess(data, xseq, params) -> pd.DataFrame:
     """
     Lowess fitting
     """
@@ -351,7 +351,7 @@ def lowess(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def loess(data, xseq, **params) -> pd.DataFrame:
+def loess(data, xseq, params) -> pd.DataFrame:
     """
     Loess smoothing
     """
@@ -402,7 +402,7 @@ def loess(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def mavg(data, xseq, **params) -> pd.DataFrame:
+def mavg(data, xseq, params) -> pd.DataFrame:
     """
     Fit moving average
     """
@@ -426,7 +426,7 @@ def mavg(data, xseq, **params) -> pd.DataFrame:
     return data
 
 
-def gpr(data, xseq, **params):
+def gpr(data, xseq, params):
     """
     Fit gaussian process
     """

plotnine/stats/stat.py

@@ -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,7 +332,7 @@ 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)
@@ -365,9 +356,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,7 +380,7 @@ 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, other: ggplot) -> ggplot:
         """

plotnine/stats/stat_bin.py

@@ -100,7 +100,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 +107,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"):