plotnine 0.15.0.dev2__py3-none-any.whl → 0.15.1__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

@@ -0,0 +1,85 @@
+"""
+These are functions that can be called by the user inside the aes()
+mapping. This is meant to make it easy to transform column-variables
+as easily as is possible in ggplot2.
+
+We only implement the most common functions.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+
+if TYPE_CHECKING:
+    from typing import Any, Sequence
+
+__all__ = (
+    "factor",
+    "reorder",
+)
+
+
+def factor(
+    values: Sequence[Any],
+    categories: Sequence[Any] | None = None,
+    ordered: bool | None = None,
+) -> pd.Categorical:
+    """
+    Turn x in to a categorical (factor) variable
+
+    It is just an alias to `pandas.Categorical`
+
+    Parameters
+    ----------
+    values :
+        The values of the categorical. If categories are given, values not in
+        categories will be replaced with NaN.
+    categories :
+        The unique categories for this categorical. If not given, the
+        categories are assumed to be the unique values of `values`
+        (sorted, if possible, otherwise in the order in which they appear).
+    ordered :
+        Whether or not this categorical is treated as a ordered categorical.
+        If True, the resulting categorical will be ordered.
+        An ordered categorical respects, when sorted, the order of its
+        `categories` attribute (which in turn is the `categories` argument, if
+        provided).
+    """
+    return pd.Categorical(values, categories=categories, ordered=None)  # pyright: ignore[reportArgumentType]
+
+
+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`.
+    """
+    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)

plotnine/mapping/aes.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
 
 import re
-import typing
 from collections.abc import Iterable, Sequence
 from contextlib import suppress
 from copy import deepcopy
 from dataclasses import fields
 from functools import cached_property
-from typing import Any, Dict
+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
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from typing import Protocol, TypeVar
 
     class ColorOrColour(Protocol):
@@ -172,27 +173,11 @@ class aes(Dict[str, Any]):
       ggplot(df, aes(x="df.index", y="np.sin(gam ma)"))
       ```
 
-    `aes` has 2 internal methods you can use to transform variables being
-    mapped.
+    `aes` has 2 internal functions that you can use in your expressions
+    when transforming the variables.
 
-      1. `factor` - This function turns the variable into a factor.
-         It is just an alias to `pandas.Categorical`:
-
-         ```python
-         ggplot(mtcars, aes(x="factor(cyl)")) + geom_bar()
-         ```
-
-      2. `reorder` - This function changes the order of first variable
-         based on values of the second variable:
-
-         ```python
-         df = pd.DataFrame({
-             "x": ["b", "d", "c", "a"],
-             "y": [1, 2, 3, 4]
-         })
-
-         ggplot(df, aes("reorder(x, y)", "y")) + geom_col()
-         ```
+      1. [](:func:`~plotnine.mapping._eval_environment.factor`)
+      1. [](:func:`~plotnine.mapping._eval_environment.reorder`)
 
     **The group aesthetic**
 
@@ -299,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)
@@ -555,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",
@@ -586,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
+
+        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: