plotnine 0.15.0.dev3__py3-none-any.whl → 0.15.2__py3-none-any.whl

plotnine/layer.py

@@ -8,7 +8,7 @@ import pandas as pd
 
 from ._utils import array_kind, check_required_aesthetics, ninteraction
 from .exceptions import PlotnineError
-from .mapping.aes import NO_GROUP, SCALED_AESTHETICS, aes
+from .mapping.aes import NO_GROUP, SCALED_AESTHETICS, aes, make_labels
 from .mapping.evaluation import evaluate, stage
 
 if typing.TYPE_CHECKING:
@@ -125,16 +125,16 @@ class layer:
                 lkwargs[param] = geom.DEFAULT_PARAMS[param]
         return layer(**lkwargs)
 
-    def __radd__(self, plot: ggplot) -> ggplot:
+    def __radd__(self, other: ggplot) -> ggplot:
         """
         Add layer to ggplot object
         """
         try:
-            plot.layers.append(self)
+            other.layers.append(self)
         except AttributeError as e:
-            msg = f"Cannot add layer to object of type {type(plot)!r}"
+            msg = f"Cannot add layer to object of type {type(other)!r}"
             raise PlotnineError(msg) from e
-        return plot
+        return other
 
     def __deepcopy__(self, memo: dict[Any, Any]) -> layer:
         """
@@ -163,6 +163,7 @@ class layer:
         self._make_layer_data(plot.data)
         self._make_layer_mapping(plot.mapping)
         self._make_layer_environments(plot.environment)
+        self._share_layer_params()
 
     def _make_layer_data(self, plot_data: DataLike | None):
         """
@@ -250,6 +251,14 @@ class layer:
         self.geom.environment = plot_environment
         self.stat.environment = plot_environment
 
+    def _share_layer_params(self):
+        """
+        Pass necessary layer parameters to the geom
+        """
+        self.geom.params["zorder"] = self.zorder
+        self.geom.params["raster"] = self.raster
+        self.geom.params["inherit_aes"] = self.inherit_aes
+
     def compute_aesthetics(self, plot: ggplot):
         """
         Return a dataframe where the columns match the aesthetic mappings
@@ -278,10 +287,10 @@ class layer:
         if not len(data):
             return
 
-        params = self.stat.setup_params(data)
+        self.stat.setup_params(data)
         data = self.stat.use_defaults(data)
         data = self.stat.setup_data(data)
-        data = self.stat.compute_layer(data, params, layout)
+        data = self.stat.compute_layer(data, layout)
         self.data = data
 
     def map_statistic(self, plot: ggplot):
@@ -289,7 +298,9 @@ class layer:
         Mapping aesthetics to computed statistics
         """
         # Mixin default stat aesthetic mappings
-        calculated = self.mapping.inherit(self.stat.DEFAULT_AES)._calculated
+        calculated = (
+            aes(**self.stat.DEFAULT_AES)._calculated | self.mapping._calculated
+        )
 
         if not len(self.data) or not calculated:
             return
@@ -320,6 +331,9 @@ class layer:
         if len(data) == 0:
             return
 
+        self.geom.params.update(self.stat.params)
+        self.geom.setup_params(data)
+        self.geom.setup_aes_params(data)
         data = self.geom.setup_data(data)
 
         check_required_aesthetics(
@@ -357,14 +371,10 @@ class layer:
         coord : coord
             Type of coordinate axes
         """
-        params = copy(self.geom.params)
-        params.update(self.stat.params)
-        params["zorder"] = self.zorder
-        params["raster"] = self.raster
         self.data = self.geom.handle_na(self.data)
         # At this point each layer must have the data
         # that is created by the plot build process
-        self.geom.draw_layer(self.data, layout, coord, **params)
+        self.geom.draw_layer(self.data, layout, coord)
 
     def use_defaults(
         self,
@@ -399,7 +409,14 @@ class layer:
         """
         Prepare/modify data for plotting
         """
-        self.stat.finish_layer(self.data, self.stat.params)
+        self.stat.finish_layer(self.data)
+
+    def update_labels(self, plot: ggplot):
+        """
+        Update label data for the ggplot from the mappings in this layer
+        """
+        plot.labels.add_defaults(self.mapping.labels)
+        plot.labels.add_defaults(make_labels(self.stat.DEFAULT_AES))
 
 
 class Layers(List[layer]):
@@ -450,7 +467,9 @@ class Layers(List[layer]):
         return [l.data for l in self]
 
     def setup(self, plot: ggplot):
-        for l in self:
+        # If zorder is 0, it is left to MPL
+        for i, l in enumerate(self, start=1):
+            l.zorder = i
             l.setup(plot)
 
     def setup_data(self):
@@ -458,9 +477,7 @@ class Layers(List[layer]):
             l.setup_data()
 
     def draw(self, layout: Layout, coord: coord):
-        # If zorder is 0, it is left to MPL
-        for i, l in enumerate(self, start=1):
-            l.zorder = i
+        for l in self:
             l.draw(layout, coord)
 
     def compute_aesthetics(self, plot: ggplot):
@@ -501,7 +518,7 @@ class Layers(List[layer]):
 
     def update_labels(self, plot: ggplot):
         for l in self:
-            plot._update_labels(l)
+            l.update_labels(plot)
 
 
 def add_group(data: pd.DataFrame) -> pd.DataFrame:

plotnine/mapping/_atomic.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Generic,
+    Literal,
+    Sequence,
+    TypeAlias,
+    TypeVar,
+)
+
+import numpy as np
+from mizani._colors.utils import is_color_tuple
+
+# NOTE:For now we shall use these class privately and not list them
+# in documentation. We can't deal with assigning Sequence[ae_value]
+# to an aesthetic.
+
+__all__ = (
+    "linetype",
+    "color",
+    "colour",
+    "fill",
+    "shape",
+)
+
+T = TypeVar("T")
+
+ShapeType: TypeAlias = (
+    str | tuple[int, Literal[0, 1, 2], float] | Sequence[tuple[float, float]]
+)
+
+
+@dataclass
+class ae_value(Generic[T]):
+    """
+    Atomic aesthetic value
+
+    The goal of this base class is simplify working with the more complex
+    aesthetic values. e.g. if a value is a tuple, we don't want it to be
+    seen as a sequence of values when assigning it to a dataframe column.
+    The subclasses should be able to recognise valid aesthetic values and
+    repeat (using multiplication) the value any number of times.
+    """
+
+    value: T
+
+    def __mul__(self, n: int) -> Sequence[T]:
+        """
+        Repeat value n times
+        """
+        return [self.value] * n
+
+
+@dataclass
+class linetype(ae_value[str | tuple]):
+    """
+    A single linetype value
+    """
+
+    def __post_init__(self):
+        value = self.value
+        named = {
+            " ",
+            "",
+            "-",
+            "--",
+            "-.",
+            ":",
+            "None",
+            "none",
+            "dashdot",
+            "dashed",
+            "dotted",
+            "solid",
+        }
+        if self.value in named:
+            return
+
+        # tuple of the form (offset, (on, off, on, off, ...))
+        # e.g (0, (1, 2))
+        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
+
+        raise ValueError(f"{value} is not a known linetype.")
+
+
+@dataclass
+class color(ae_value[str | tuple]):
+    """
+    A single color value
+    """
+
+    def __post_init__(self):
+        if isinstance(self.value, str):
+            return
+        elif is_color_tuple(self.value):
+            self.value = tuple(self.value)
+            return
+
+        raise ValueError(f"{self.value} is not a known color.")
+
+
+colour = color
+
+
+@dataclass
+class fill(color):
+    """
+    A single color value
+    """
+
+
+@dataclass
+class shape(ae_value[ShapeType]):
+    """
+    A single shape value
+    """
+
+    def __post_init__(self):
+        from matplotlib.path import Path
+
+        from ..scales.scale_shape import FILLED_SHAPES, UNFILLED_SHAPES
+
+        value = self.value
+
+        with suppress(TypeError):
+            if value in (FILLED_SHAPES | UNFILLED_SHAPES):
+                return
+
+        if isinstance(value, Path):
+            return
+
+        # tuple of the form (numsides, style, angle)
+        # where style is in the range [0, 3]
+        # e.g (4, 1, 45)
+        if (
+            isinstance(value, tuple)
+            and len(value) == 3
+            and isinstance(value[0], int)
+            and value[1] in (0, 1, 2)
+            and isinstance(value[2], (float, int))
+        ):
+            return
+
+        if is_shape_points(value):
+            self.value = tuple(value)  # pyright: ignore[reportAttributeAccessIssue]
+            return
+
+        raise ValueError(f"{value} is not a known shape.")
+
+
+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 (ValueError, TypeError):
+        return False

plotnine/mapping/_env.py

@@ -10,6 +10,8 @@ if TYPE_CHECKING:
     from collections.abc import Iterator
     from typing import Any, Hashable, Protocol, Self
 
+    from patsy.eval import EvalEnvironment
+
     class SupportsGetItem(Protocol):
         """
         Supports __getitem__
@@ -110,6 +112,15 @@ class Environment:
         finally:
             del frame
 
+    def to_patsy_env(self) -> EvalEnvironment:
+        """
+        Convert a plotnine environment to a patsy environment
+        """
+        from patsy.eval import EvalEnvironment
+
+        eval_env = EvalEnvironment(self.namespaces)
+        return eval_env
+
     def _namespace_ids(self):
         return [id(n) for n in self.namespaces]
 
@@ -122,7 +133,7 @@ class Environment:
     def __hash__(self):
         return hash((Environment, tuple(self._namespace_ids())))
 
-    def __getstate__(*args, **kwargs):
+    def __getstate__(self):
         """
         Return state with no namespaces
         """
@@ -198,7 +209,7 @@ class StackedLookup(MutableMapping):
     def __repr__(self):
         return f"{self.__class__.__name__}({self.stack})"
 
-    def __getstate__(*args, **kwargs):
+    def __getstate__(self):
         """
         Return state with no namespace
         """

plotnine/mapping/_eval_environment.py

@@ -48,7 +48,7 @@ def factor(
         `categories` attribute (which in turn is the `categories` argument, if
         provided).
     """
-    return pd.Categorical(values, categories=categories, ordered=None)
+    return pd.Categorical(values, categories=categories, ordered=None)  # pyright: ignore[reportArgumentType]
 
 
 def reorder(x, y, fun=np.median, ascending=True):

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
@@ -282,14 +284,20 @@ class aes(Dict[str, Any]):
 
         return result
 
-    def __radd__(self, plot):
+    def __radd__(self, other):
         """
         Add aesthetic mappings to ggplot
         """
         self = deepcopy(self)
-        plot.mapping.update(self)
-        plot.labels.update(make_labels(self))
-        return plot
+        other.mapping.update(self)
+        return other
+
+    @property
+    def labels(self) -> labels_view:
+        """
+        The labels for this mapping
+        """
+        return make_labels(self)
 
     def copy(self):
         return aes(**self)
@@ -538,23 +546,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 +577,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
 
-    # For any other aesthetics we return False to allow
-    # for special cases to be discovered and then coded
-    # for appropriately.
-    return False
+        if is_shape_points(value):
+            return [tuple(value)] * n
+
+        raise ValueError(f"{value} is not a know shape.")
+
+
+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/__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):
         """