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

plotnine/mapping/evaluation.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 import numbers
-import typing
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
 import pandas.api.types as pdtypes
 
 from ..exceptions import PlotnineError
+from ._eval_environment import factor, reorder
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from typing import Any
 
     from . import aes
@@ -18,6 +19,9 @@ if typing.TYPE_CHECKING:
 
 __all__ = ("after_stat", "after_scale", "stage")
 
+
+EVAL_ENVIRONMENT = {"factor": factor, "reorder": reorder}
+
 _TPL_EVAL_FAIL = """\
 Could not evaluate the '{}' mapping: '{}' \
 (original error: {})"""
@@ -108,68 +112,6 @@ def after_scale(x):
     return stage(after_scale=x)
 
 
-def reorder(x, y, fun=np.median, ascending=True):
-    """
-    Reorder categorical by sorting along another variable
-
-    It is the order of the categories that changes. Values in x
-    are grouped by categories and summarised to determine the
-    new order.
-
-    Credit: Copied from plydata
-
-    Parameters
-    ----------
-    x : list-like
-        Values that will make up the categorical.
-    y : list-like
-        Values by which `c` will be ordered.
-    fun : callable
-        Summarising function to `x` for each category in `c`.
-        Default is the *median*.
-    ascending : bool
-        If `True`, the `c` is ordered in ascending order of `x`.
-
-    Examples
-    --------
-    >>> c = list('abbccc')
-    >>> x = [11, 2, 2, 3, 33, 3]
-    >>> cat_reorder(c, x)
-    [a, b, b, c, c, c]
-    Categories (3, object): [b, c, a]
-    >>> cat_reorder(c, x, fun=max)
-    [a, b, b, c, c, c]
-    Categories (3, object): [b, a, c]
-    >>> cat_reorder(c, x, fun=max, ascending=False)
-    [a, b, b, c, c, c]
-    Categories (3, object): [c, a, b]
-    >>> c_ordered = pd.Categorical(c, ordered=True)
-    >>> cat_reorder(c_ordered, x)
-    [a, b, b, c, c, c]
-    Categories (3, object): [b < c < a]
-    >>> cat_reorder(c + ['d'], x)
-    Traceback (most recent call last):
-        ...
-    ValueError: Lengths are not equal. len(c) is 7 and len(x) is 6.
-    """
-    if len(x) != len(y):
-        raise ValueError(f"Lengths are not equal. {len(x)=}, {len(x)=}")
-    summary = (
-        pd.Series(y)
-        .groupby(x, observed=True)
-        .apply(fun)
-        .sort_values(ascending=ascending)
-    )
-    cats = summary.index.to_list()
-    return pd.Categorical(x, categories=cats)
-
-
-# These are function that can be called by the user inside the aes()
-# mapping. This is meant to make the variable transformations as easy
-# as they are in ggplot2
-AES_INNER_NAMESPACE = {"factor": pd.Categorical, "reorder": reorder}
-
-
 def evaluate(
     aesthetics: aes | dict[str, Any], data: pd.DataFrame, env: Environment
 ) -> pd.DataFrame:
@@ -207,7 +149,7 @@ def evaluate(
     3  16
     4  25
     """
-    env = env.with_outer_namespace(AES_INNER_NAMESPACE)
+    env = env.with_outer_namespace(EVAL_ENVIRONMENT)
 
     # Store evaluation results in a dict column in a dict
     evaled = {}

plotnine/scales/__init__.py

@@ -74,6 +74,7 @@ from .scale_identity import (
     scale_linetype_identity,
     scale_shape_identity,
     scale_size_identity,
+    scale_stroke_identity,
 )
 
 # linetype
@@ -217,6 +218,7 @@ __all__ = (
     "scale_linetype_identity",
     "scale_shape_identity",
     "scale_size_identity",
+    "scale_stroke_identity",
     # manual
     "scale_color_manual",
     "scale_colour_manual",

plotnine/scales/limits.py

@@ -78,10 +78,10 @@ class _lim:
             self.aesthetic, series, limits=self.limits, trans=self.trans
         )
 
-    def __radd__(self, plot):
-        scale = self.get_scale(plot)
-        plot.scales.append(scale)
-        return plot
+    def __radd__(self, other):
+        scale = self.get_scale(other)
+        other.scales.append(scale)
+        return other
 
 
 class xlim(_lim):
@@ -194,7 +194,7 @@ class lims:
     def __init__(self, **kwargs):
         self._kwargs = kwargs
 
-    def __radd__(self, plot):
+    def __radd__(self, other):
         """
         Add limits to ggplot object
         """
@@ -206,9 +206,9 @@ class lims:
                 msg = "Cannot change limits for '{}'"
                 raise PlotnineError(msg) from e
 
-            plot += klass(value)
+            other += klass(value)
 
-        return plot
+        return other
 
 
 def expand_limits(**kwargs):

plotnine/scales/scale.py

@@ -148,12 +148,12 @@ class scale(
             self.aesthetics if self.aesthetics else self._aesthetics
         )
 
-    def __radd__(self, plot):
+    def __radd__(self, other):
         """
         Add this scale to ggplot object
         """
-        plot.scales.append(copy(self))
-        return plot
+        other.scales.append(copy(self))
+        return other
 
     def map(self, x, limits=None):
         """

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
 
@@ -48,36 +48,72 @@ class _scale_color_continuous(
 class scale_color_hue(_scale_color_discrete):
     """
     Qualitative color scale with evenly spaced hues
+
+    See Also
+    --------
+    mizani.palettes.hue_pal : The palette class that generates colours
+        in HCL space.
     """
 
-    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 used and will be removed in a future version
+    """
+    color_space: None = field(default=None, repr=False)
+    """
+    Not being used 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)
 
 
 @dataclass
@@ -95,6 +131,11 @@ class scale_color_brewer(_scale_color_discrete):
     Sequential, diverging and qualitative discrete color scales
 
     See `colorbrewer.org <http://colorbrewer2.org/>`_
+
+    See Also
+    --------
+    mizani.palette.brewer_pal : The palette class that generates colours
+        that generates the brewer colors.
     """
 
     type: InitVar[
@@ -146,6 +187,11 @@ class scale_fill_brewer(scale_color_brewer):
 class scale_color_grey(_scale_color_discrete):
     """
     Sequential grey color scale.
+
+    See Also
+    --------
+    mizani.palettes.grey_pal : The palette class that generates colours
+        gray scale color.
     """
 
     start: InitVar[float] = 0.2
@@ -188,6 +234,8 @@ class scale_color_gradient(_scale_color_continuous):
     --------
     plotnine.scale_color_gradient2
     plotnine.scale_color_gradientn
+    mizani.palettes.gradient_n_pal : The palette class that generates
+        the colour gradient.
     """
 
     low: InitVar[str] = "#132B43"
@@ -220,6 +268,11 @@ class scale_fill_gradient(scale_color_gradient):
 class scale_color_desaturate(_scale_color_continuous):
     """
     Create a desaturated color gradient
+
+    See Also
+    --------
+    mizani.palettes.desaturate_pal : The palette class that generates
+        the desaturated colours.
     """
 
     color: InitVar[str] = "red"
@@ -263,6 +316,8 @@ class scale_color_gradient2(_scale_color_continuous):
     --------
     plotnine.scale_color_gradient
     plotnine.scale_color_gradientn
+    mizani.palettes.gradient_n_pal : The palette class that generates
+        the colour gradient.
     """
 
     low: InitVar[str] = "#832424"
@@ -316,9 +371,11 @@ class scale_color_gradientn(_scale_color_continuous):
     --------
     plotnine.scale_color_gradient
     plotnine.scale_color_gradientn
+    mizani.palettes.gradient_n_pal : The palette class that generates
+        the colour gradient.
     """
 
-    colors: InitVar[Sequence[str]] = "#832424"
+    colors: InitVar[Sequence[str]]
     """
     List of colors
     """
@@ -332,8 +389,8 @@ class scale_color_gradientn(_scale_color_continuous):
     def __post_init__(self, colors, values):
         from mizani.palettes import gradient_n_pal
 
-        self.palette = gradient_n_pal(colors, values)
         super().__post_init__()
+        self.palette = gradient_n_pal(colors, values)
 
 
 @dataclass
@@ -430,6 +487,8 @@ class scale_color_cmap(_scale_color_continuous):
     --------
     [](`matplotlib.cm`)
     [](`matplotlib.colors`)
+    mizani.palettes.cmap_pal : The palette class that generates
+        the colour gradients of this scale.
     """
 
     cmap_name: InitVar[str] = "viridis"
@@ -457,7 +516,7 @@ class scale_fill_cmap(scale_color_cmap):
 
 
 @dataclass
-class scale_color_cmap_d(scale_discrete):
+class scale_color_cmap_d(_scale_color_discrete):
     """
     A discrete color scales using Matplotlib colormaps
 
@@ -465,6 +524,8 @@ class scale_color_cmap_d(scale_discrete):
     --------
     [](`matplotlib.cm`)
     [](`matplotlib.colors`)
+    mizani.palettes.cmap_pal : The palette class that generates
+        the colours of this scale.
     """
 
     cmap_name: InitVar[str] = "viridis"
@@ -474,7 +535,6 @@ class scale_color_cmap_d(scale_discrete):
     `matplotlib.cm.cmap_d.keys()` or see the
     `documentation <http://matplotlib.org/users/colormaps.html>`_.
     """
-    _aesthetics = ["color"]
 
     def __post_init__(self, cmap_name):
         from mizani.palettes import cmap_d_pal
@@ -496,6 +556,10 @@ class scale_fill_cmap_d(scale_color_cmap_d):
 class scale_color_datetime(scale_datetime, scale_color_cmap):  # pyright: ignore[reportIncompatibleVariableOverride]
     """
     Datetime color scale
+
+    See Also
+    --------
+    plotnine.scale_color_cmap : The parent class.
     """
 
     _: KW_ONLY

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(
@@ -520,11 +521,12 @@ class scale_continuous(
             # When user sets breaks and labels of equal size,
             # but the limits exclude some of the breaks.
             # We remove the corresponding labels
-            from collections.abc import Sized
+            from collections.abc import Iterable, Sized
 
             labels = self.labels
             if (
                 len(labels) != len(breaks)
+                and isinstance(self.breaks, Iterable)
                 and isinstance(self.breaks, Sized)
                 and len(labels) == len(self.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_identity.py

@@ -43,6 +43,8 @@ class scale_color_identity(MapTrainMixin, scale_discrete):
     """
 
     _aesthetics = ["color"]
+    _: KW_ONLY
+    guide: Literal["legend"] | None = None
 
 
 @dataclass
@@ -52,6 +54,8 @@ class scale_fill_identity(scale_color_identity):
     """
 
     _aesthetics = ["fill"]
+    _: KW_ONLY
+    guide: Literal["legend"] | None = None
 
 
 @dataclass
@@ -61,6 +65,8 @@ class scale_shape_identity(MapTrainMixin, scale_discrete):
     """
 
     _aesthetics = ["shape"]
+    _: KW_ONLY
+    guide: Literal["legend"] | None = None
 
 
 @dataclass
@@ -70,6 +76,8 @@ class scale_linetype_identity(MapTrainMixin, scale_discrete):
     """
 
     _aesthetics = ["linetype"]
+    _: KW_ONLY
+    guide: Literal["legend"] | None = None
 
 
 @dataclass
@@ -82,7 +90,7 @@ class scale_alpha_identity(
 
     _aesthetics = ["alpha"]
     _: KW_ONLY
-    guide: Literal["legend"] | None = "legend"
+    guide: Literal["legend"] | None = None
 
 
 @dataclass
@@ -95,7 +103,18 @@ class scale_size_identity(
 
     _aesthetics = ["size"]
     _: KW_ONLY
-    guide: Literal["legend"] | None = "legend"
+    guide: Literal["legend"] | None = None
+
+
+@dataclass
+class scale_stroke_identity(MapTrainMixin, scale_discrete):
+    """
+    No stroke scaling
+    """
+
+    _aesthetics = ["stroke"]
+    _: KW_ONLY
+    guide: Literal["legend"] | None = None
 
 
 # American to British spelling

plotnine/scales/scale_manual.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import KW_ONLY, InitVar, dataclass
 from typing import Any, Sequence
 from warnings import warn
@@ -21,11 +22,16 @@ class _scale_manual(scale_discrete):
     """
 
     def __post_init__(self, values):
-        from collections.abc import Sized
+        from collections.abc import Iterable, Sized
 
         super().__post_init__()
 
-        if isinstance(self.breaks, Sized) and len(self.breaks) == len(values):
+        if (
+            isinstance(self.breaks, Iterable)
+            and isinstance(self.breaks, Sized)
+            and len(self.breaks) == len(values)
+            and not isinstance(values, Mapping)
+        ):
             values = dict(zip(self.breaks, values))
 
         def palette(n):

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/binning.py

@@ -165,7 +165,10 @@ def assign_bins(
     if weight is None:
         weight = np.ones(len(x))
     else:
-        weight = np.asarray(weight)
+        # If weight is a dtype that isn't writeable
+        # and does not own it's memory. Using a list
+        # as an intermediate easily solves this.
+        weight = np.array(list(weight))
         weight[np.isnan(weight)] = 0
 
     bin_idx = pd.cut(