plotnine 0.15.0a3__py3-none-any.whl → 0.15.0a5__py3-none-any.whl

plotnine/_utils/__init__.py

@@ -12,9 +12,10 @@ from collections.abc import Iterable, Sequence
 from contextlib import suppress
 from copy import deepcopy
 from dataclasses import field
-from typing import TYPE_CHECKING, cast, overload
+from typing import TYPE_CHECKING
 from warnings import warn
 
+import mizani._colors.utils as color_utils
 import numpy as np
 import pandas as pd
 from pandas.core.groupby import DataFrameGroupBy
@@ -26,12 +27,10 @@ if TYPE_CHECKING:
     from typing import Any, Callable, Literal, TypeVar
 
     import numpy.typing as npt
-    from matplotlib.typing import ColorType
     from typing_extensions import TypeGuard
 
     from plotnine.typing import (
         AnyArrayLike,
-        AnySeries,
         DataLike,
         FloatArray,
         FloatArrayLike,
@@ -60,6 +59,8 @@ BOX_LOCATIONS: dict[str, tuple[float, float]] = {
     "centre": (0.5, 0.5),
 }
 
+to_rgba = color_utils.to_rgba
+
 
 def is_scalar(val):
     """
@@ -361,7 +362,7 @@ def _id_var(x: AnyArrayLike, drop: bool = False) -> list[int]:
         lst = match(x, levels)
         lst = [item + 1 for item in lst]
 
-    return lst  # pyright: ignore[reportReturnType]
+    return lst
 
 
 def join_keys(x, y, by=None):
@@ -530,105 +531,6 @@ def remove_missing(
     return data
 
 
-@overload
-def to_rgba(colors: ColorType, alpha: float) -> ColorType: ...
-
-
-@overload
-def to_rgba(
-    colors: Sequence[ColorType], alpha: float
-) -> Sequence[ColorType] | ColorType: ...
-
-
-@overload
-def to_rgba(
-    colors: AnySeries, alpha: AnySeries
-) -> Sequence[ColorType] | ColorType: ...
-
-
-def to_rgba(
-    colors: Sequence[ColorType] | AnySeries | ColorType,
-    alpha: float | Sequence[float] | AnySeries,
-) -> Sequence[ColorType] | ColorType:
-    """
-    Convert hex colors to rgba values.
-
-    Parameters
-    ----------
-    colors : iterable | str
-        colors to convert
-    alphas : iterable | float
-        alpha values
-
-    Returns
-    -------
-    out : ndarray | tuple
-        rgba color(s)
-
-    Notes
-    -----
-    Matplotlib plotting functions only accept scalar
-    alpha values. Hence no two objects with different
-    alpha values may be plotted in one call. This would
-    make plots with continuous alpha values innefficient.
-    However :), the colors can be rgba hex values or
-    list-likes and the alpha dimension will be respected.
-    """
-
-    def is_iterable(var):
-        return np.iterable(var) and not isinstance(var, str)
-
-    def has_alpha(c):
-        return (isinstance(c, tuple) and len(c) == 4) or (
-            isinstance(c, str) and len(c) == 9 and c[0] == "#"
-        )
-
-    def no_color(c):
-        return c is None or c.lower() in ("none", "")
-
-    def to_rgba_hex(c: ColorType, a: float) -> str:
-        """
-        Convert rgb color to rgba hex value
-
-        If color c has an alpha channel, then alpha value
-        a is ignored
-        """
-        from matplotlib.colors import colorConverter, to_hex
-
-        if c in ("None", "none"):
-            return c
-
-        _has_alpha = has_alpha(c)
-        c = to_hex(c, keep_alpha=_has_alpha)
-
-        if not _has_alpha:
-            arr = colorConverter.to_rgba(c, a)
-            return to_hex(arr, keep_alpha=True)
-
-        return c
-
-    if is_iterable(colors):
-        colors = cast("Sequence[ColorType]", colors)
-
-        if all(no_color(c) for c in colors):
-            return "none"
-
-        if isinstance(alpha, (Sequence, pd.Series)):
-            return [to_rgba_hex(c, a) for c, a in zip(colors, alpha)]
-        else:
-            return [to_rgba_hex(c, alpha) for c in colors]
-    else:
-        colors = cast("ColorType", colors)
-
-        if no_color(colors):
-            return colors
-
-        if isinstance(alpha, (Sequence, pd.Series)):
-            return [to_rgba_hex(colors, a) for a in alpha]
-        else:
-            return to_rgba_hex(colors, alpha)
-
-
 def groupby_apply(
     df: pd.DataFrame,
     cols: str | list[str],

plotnine/doctools.py

@@ -71,7 +71,7 @@ STAT_SIGNATURE_TPL = """
 
 common_params_doc = {
     "mapping": """\
-Aesthetic mappings created with [aes](:class:`plotnine.mapping.aes`). If \
+Aesthetic mappings created with [aes](:class:`plotnine.mapping.aes.aes`). If \
 specified and `inherit_aes=True`{.py}, it is combined with the default \
 mapping for the plot. You must supply mapping if there is no plot mapping.""",
     "data": """\
@@ -103,7 +103,7 @@ the final image is in vector format.""",
 
 
 GEOM_PARAMS_TPL = """
-mapping : ~plotnine.mapping.aes, default=None
+mapping : ~plotnine.mapping.aes.aes, default=None
     {mapping}
     {_aesthetics_doc}
 data : ~pandas.DataFrame, default=None
@@ -124,7 +124,7 @@ raster : bool, default={default_raster}
 """
 
 STAT_PARAMS_TPL = """
-mapping : ~plotnine.mapping.aes, default=None
+mapping : ~plotnine.mapping.aes.aes, default=None
     {mapping}
     {_aesthetics_doc}
 data : ~pandas.DataFrame, default=None

plotnine/geoms/annotate.py

@@ -64,16 +64,16 @@ class annotate:
     def __init__(
         self,
         geom: str | type[geom_base_class],
-        x: float | None = None,
-        y: float | None = None,
-        xmin: float | None = None,
-        xmax: float | None = None,
-        xend: float | None = None,
-        xintercept: float | None = None,
-        ymin: float | None = None,
-        ymax: float | None = None,
-        yend: float | None = None,
-        yintercept: float | None = None,
+        x: float | list[float] | None = None,
+        y: float | list[float] | None = None,
+        xmin: float | list[float] | None = None,
+        xmax: float | list[float] | None = None,
+        xend: float | list[float] | None = None,
+        xintercept: float | list[float] | None = None,
+        ymin: float | list[float] | None = None,
+        ymax: float | list[float] | None = None,
+        yend: float | list[float] | None = None,
+        yintercept: float | list[float] | None = None,
         **kwargs: Any,
     ):
         variables = locals()

plotnine/geoms/geom.py

@@ -2,18 +2,20 @@ from __future__ import annotations
 
 import typing
 from abc import ABC
+from contextlib import suppress
 from copy import deepcopy
 from itertools import chain, repeat
 
+import numpy as np
+
 from .._utils import (
     data_mapping_as_kwargs,
-    is_list_like,
     remove_missing,
 )
 from .._utils.registry import Register, Registry
 from ..exceptions import PlotnineError
 from ..layer import layer
-from ..mapping.aes import is_valid_aesthetic, rename_aesthetics
+from ..mapping.aes import rename_aesthetics
 from ..mapping.evaluation import evaluate
 from ..positions.position import position
 from ..stats.stat import stat
@@ -179,11 +181,16 @@ class geom(ABC, metaclass=Register):
         ----------
         data :
             Data
+        """
 
-        Returns
-        -------
-        out :
-            Parameters used by the geoms.
+    def setup_aes_params(self, data: pd.DataFrame):
+        """
+        Override this method to verify and/or adjust aesthetic parameters
+
+        Parameters
+        ----------
+        data :
+            Data
         """
 
     def setup_data(self, data: pd.DataFrame) -> pd.DataFrame:
@@ -239,6 +246,9 @@ class geom(ABC, metaclass=Register):
         :
             Data used for drawing the geom.
         """
+        from plotnine.mapping import _atomic as atomic
+        from plotnine.mapping._atomic import ae_value
+
         missing_aes = (
             self.DEFAULT_AES.keys()
             - self.aes_params.keys()
@@ -255,23 +265,34 @@ class geom(ABC, metaclass=Register):
             data[ae] = evaled[ae]
 
         num_panels = len(data["PANEL"].unique()) if "PANEL" in data else 1
+        across_panels = num_panels > 1 and not self.params["inherit_aes"]
 
-        # Aesthetics set as parameters to the geom/stat
+        # Aesthetics set as parameters in the geom/stat
         for ae, value in self.aes_params.items():
-            try:
+            if isinstance(value, (str, int, float, np.integer, np.floating)):
+                data[ae] = value
+            elif isinstance(value, ae_value):
+                data[ae] = value * len(data)
+            elif across_panels:
+                value = list(chain(*repeat(value, num_panels)))
                 data[ae] = value
-            except ValueError as e:
-                # sniff out the special cases, like custom
-                # tupled linetypes, shapes and colors
-                if is_valid_aesthetic(value, ae):
-                    data[ae] = [value] * len(data)
-                elif num_panels > 1 and is_list_like(value):
-                    data[ae] = list(chain(*repeat(value, num_panels)))
-                else:
-                    msg = (
-                        f"'{value}' does not look like a "
-                        f"valid value for `{ae}`"
-                    )
+            else:
+                # Try to make sense of aesthetics whose values can be tuples
+                # or sequences of sorts.
+                ae_value_cls: type[ae_value] | None = getattr(atomic, ae, None)
+                if ae_value_cls:
+                    with suppress(ValueError):
+                        data[ae] = ae_value_cls(value) * len(data)
+                        continue
+
+                # This should catch the aesthetic assignments to
+                # non-numeric or non-string values or sequence of values.
+                # e.g. x=datetime, x=Sequence[datetime],
+                #      x=Sequence[float], shape=Sequence[str]
+                try:
+                    data[ae] = value
+                except ValueError as e:
+                    msg = f"'{ae}={value}' does not look like a valid value"
                     raise PlotnineError(msg) from e
 
         return data

plotnine/layer.py

@@ -257,6 +257,7 @@ class layer:
         """
         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):
         """
@@ -330,6 +331,7 @@ class layer:
 
         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(

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

@@ -396,7 +396,7 @@ class scale_continuous(
             scaled = [na_value if x == "nan" else x for x in scaled]
         else:
             scaled[pd.isna(scaled)] = na_value
-        return scaled  # pyright: ignore[reportReturnType]
+        return scaled
 
     def get_breaks(
         self, limits: Optional[tuple[float, float]] = None

plotnine/scales/scale_discrete.py

@@ -206,7 +206,7 @@ class scale_discrete(
                 pal = np.asarray(pal, dtype=object)
             idx = np.asarray(match(x, limits))
             try:
-                pal_match = [pal[i] if i >= 0 else None for i in idx]  # pyright: ignore[reportCallIssue,reportArgumentType]
+                pal_match = [pal[i] if i >= 0 else None for i in idx]
             except IndexError:
                 # Deal with missing data
                 # - Insert NaN where there is no match

plotnine/stats/stat_density_2d.py

@@ -155,7 +155,7 @@ def contour_lines(X, Y, Z, levels: int | FloatArrayLike):
     level_values = []
     start_pid = 1
     for level in levels:
-        vertices, *_ = cgen.create_contour(level)  # pyright: ignore[reportArgumentType]
+        vertices, *_ = cgen.create_contour(level)
         for pid, piece in enumerate(vertices, start=start_pid):
             n = len(piece)  # pyright: ignore
             segments.append(piece)

{plotnine-0.15.0a3.dist-info → plotnine-0.15.0a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotnine
-Version: 0.15.0a3
+Version: 0.15.0a5
 Summary: A Grammar of Graphics for Python
 Author-email: Hassan Kibirige <has2k1@gmail.com>
 License: The MIT License (MIT)
@@ -48,7 +48,7 @@ Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: pandas>=2.2.0
 Requires-Dist: mizani~=0.14.0
 Requires-Dist: numpy>=1.23.5
-Requires-Dist: scipy>=1.8.0
+Requires-Dist: scipy<1.16.0,>=1.8.0
 Requires-Dist: statsmodels>=0.14.0
 Provides-Extra: all
 Requires-Dist: plotnine[extra]; extra == "all"

{plotnine-0.15.0a3.dist-info → plotnine-0.15.0a5.dist-info}/RECORD

@@ -1,12 +1,12 @@
 plotnine/__init__.py,sha256=HrJhd65bnny1t-TawUgvApVj4p-gDZ0ftpr2NKZeW_s,10316
 plotnine/animation.py,sha256=izJZ4Gy0cBHEBc8ehofsWSWOzZW8UEroy1Uvw86Igb0,7521
-plotnine/doctools.py,sha256=4qR1NCnnIG1Q-F0e2MeGzlhD9X0a00dOajtcl7m-yCQ,14546
+plotnine/doctools.py,sha256=JBF55q1MX2fXYQcGDpVrGPdlKf5OiQ5gyTdWhnM_IzU,14558
 plotnine/exceptions.py,sha256=SgTxBHkV65HjGI3aFy2q1_lHP9HAdiuxVLN3U-PJWSQ,1616
 plotnine/ggplot.py,sha256=xFj9iWAyBvnhitCrpgdNonQIqqjBQ2aDgkqpvHbH364,24823
 plotnine/helpers.py,sha256=4R3KZmtGH46-kRNSGOA0JxZaLKBo0ge8Vnx1cDQ8_gI,966
 plotnine/iapi.py,sha256=jNLmUSoh5g9kNdhOoXSqNcqOdd2-6xdWAmst-YGU41U,9095
 plotnine/labels.py,sha256=3pOXth2Xma_qCqB_xXAGIkPQ9gcaUaaFEAsa5if1iR0,2830
-plotnine/layer.py,sha256=PHQbpfEK0GPXtDn87xC0J5HbKUb5_t9UYNtEyQaMYxE,16882
+plotnine/layer.py,sha256=sUtzKTPnvkMuVFsNUFPkK9HUEcX7ohqv1EQV2KryS_c,16982
 plotnine/options.py,sha256=j3zXv4wc3J4nOI_TqJ5s_abuifodt_UN8MR8M4i8UVA,3108
 plotnine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plotnine/qplot.py,sha256=BSAb4u5I7PaPGofkAgx7brdCNTjMZvC_TDGHVUZ35xM,7384
@@ -25,7 +25,7 @@ plotnine/_mpl/layout_manager/_engine.py,sha256=ESUvbLAlZApFbBi6w7gZA7S4guS0Rmrj-
 plotnine/_mpl/layout_manager/_layout_items.py,sha256=3XRBl7xEdBKdhrexRmnVe7k919po6nkyE0q5Hx7j5cQ,29642
 plotnine/_mpl/layout_manager/_layout_tree.py,sha256=O6U78CYOjSwS4lt56YF3YiOCXdxmV_oy3lYS4gMmzSc,26447
 plotnine/_mpl/layout_manager/_spaces.py,sha256=ahBpKt-q1kVOTGiGliwl_DNB6pTEekAzA_7-GXwFlBk,35789
-plotnine/_utils/__init__.py,sha256=pRCAZu_ux2uZtaJ_EZGDVFxITubGplo-3jqB7teE_KM,33239
+plotnine/_utils/__init__.py,sha256=czHi-uv4eIBCDf6td11bGA41PMXaJ5j7t-avx_JbYgY,30636
 plotnine/_utils/context.py,sha256=HPQy_uyNXdS0s9URD7ZePyuc5hFU2XrRBLDTqRDLJzY,1708
 plotnine/_utils/dev.py,sha256=0qgRbMhcd4dfuLuYxx0skocKAtfwHF02ntyILRBogbg,1629
 plotnine/_utils/ipython.py,sha256=5Obr73xJ-4dzJEdBrFA8z9TXuxY7pIjKmzdTzWwnxNk,1884
@@ -66,10 +66,10 @@ plotnine/facets/labelling.py,sha256=JEuwERTK0IfmxTWHbl2nsGgxZ6xi0n2TTWT4_OSfQcQ,
 plotnine/facets/layout.py,sha256=TIkMChA0wJWLKN31PH0czS6CN4pw3o--PF49LakJ2h4,8967
 plotnine/facets/strips.py,sha256=-SWFaxqdzn-dnjx_Hxkuwd3kO-u_yreMLcMurm_IHqU,5688
 plotnine/geoms/__init__.py,sha256=HEfhNmmNH4xm4rpXnFRXY4eLkJha3XPM72IIwVjv5Lc,2697
-plotnine/geoms/annotate.py,sha256=Dqy5j29nrd7hHF-xZk8ZsE05j0ahdCtLkES7p7zjW-4,4025
+plotnine/geoms/annotate.py,sha256=T5RxepV55HVNzPfkq43BWxduNIZPslRfPD1yx4bJtoo,4165
 plotnine/geoms/annotation_logticks.py,sha256=6iGdo5szck0_nXdHnvMaRMZuRbH8Tg87tJ_aan_frqg,8969
 plotnine/geoms/annotation_stripes.py,sha256=4Cw7TJ4SZChm_ioqfiiku0cPNnLruGuAP-4vyRao-9Y,6080
-plotnine/geoms/geom.py,sha256=Wa9DiHMQq-XznLcil6ho5QdCab6VhQtsqmGgDHUOCc0,16808
+plotnine/geoms/geom.py,sha256=ayhBEoPc-9MLpu18HkwLoby4NIKC68ED4Pq0ioa4I9c,17687
 plotnine/geoms/geom_abline.py,sha256=6oxAJl_yFKKmf7OTHvACw6fg6kgJEN54hGKkyWOLr6o,3188
 plotnine/geoms/geom_area.py,sha256=wvQ4nNvhJNN3nfn6Bv1gCARC6IWTjOjOfHPfSmg6Sxc,818
 plotnine/geoms/geom_bar.py,sha256=SnqS4hPTfqXzdPh1U-kNuBg0LNX9_tQC9OKhIlB7cy0,1732
@@ -120,9 +120,10 @@ plotnine/guides/guide_colorbar.py,sha256=gL0218k3iJPNEpj6hWKxau3R8qRpT2bPkS1q9Pt
 plotnine/guides/guide_legend.py,sha256=CrcV3iCAcEfUnSbkGtsS31c3OFQMWKiHqZZXejxOdno,14212
 plotnine/guides/guides.py,sha256=cV7CwoYNrjkeaDHZ2AGcS2Dij5RpPovSiB-v47E7vhQ,15471
 plotnine/mapping/__init__.py,sha256=DLu9E0kwwuHxzTUenoVjCNTTdkWMwIDtkExLleBq1MI,205
+plotnine/mapping/_atomic.py,sha256=TbobHVJlHRoSHibi6OOWMVM2J1r_kKQJMS6G5zvEhrg,4029
 plotnine/mapping/_env.py,sha256=ZXlTt2THRIcWb2WGk9fCpCMdVynlUX_BpG0Uwj7axi0,6072
 plotnine/mapping/_eval_environment.py,sha256=PTrnnqrxMXqjt23t2NGRcU9i8Jie3ZaMe6W5aKtI7bI,2502
-plotnine/mapping/aes.py,sha256=ZF69UUcA0IovFx2HMMKhVDnPxS9yw74LHL6C1VYwK84,15801
+plotnine/mapping/aes.py,sha256=eqNTBHqFnSBPoVNdrUB7pYM-ShlUTYvmwdQRXh9beV4,16717
 plotnine/mapping/evaluation.py,sha256=kblTxVv3M4xIGnHyReUU0RtmmIN77Or2JBcci0nGGfE,5913
 plotnine/plot_composition/__init__.py,sha256=ZJYpfVF158cQZ1zREXy6wHNJ4FbSmqWxIkHWZwX3QT8,148
 plotnine/plot_composition/_compose.py,sha256=6UgXs6VBH0LIXW2uQlBQy-URh_mM948F5GOwN6IV734,12167
@@ -146,9 +147,9 @@ plotnine/scales/range.py,sha256=xBlFdAhthH1zKIJZDdkEyAA2kMZtyDorDFHKBMHKyAQ,1379
 plotnine/scales/scale.py,sha256=T7oMfiXA2xOL_LQQIEKY_06VvXVfF-norNpc2gdTNNw,8078
 plotnine/scales/scale_alpha.py,sha256=lYVZeaCC2pk-0-BoXnOeP0RdIbHYk6qo3DRClJrxTKo,2350
 plotnine/scales/scale_color.py,sha256=6Cyjxml8Jn3EFiDY8IGvYM9_qacHvBQZFvbFh5Gyg8Q,14514
-plotnine/scales/scale_continuous.py,sha256=-mYua-hXIZa2APJNygrNXtgzpsbmelwZLkjqKQgUq-Q,16537
+plotnine/scales/scale_continuous.py,sha256=YMRjGh7QS644ajx5dVPJ9QTrWbTjmKt62MvVSFl3Y7U,16500
 plotnine/scales/scale_datetime.py,sha256=OM9gfHKGkQIBrgqCEE00zUV0cMXXxTIS7wc9dYQZ6sE,3983
-plotnine/scales/scale_discrete.py,sha256=lXlKA4sU61jrmgyvFFCVvjeVEG-FHgfDElPRzvK5jNE,9486
+plotnine/scales/scale_discrete.py,sha256=UwAB0icMljH-eW6mK3g0YWAVzuE4P_91ZMYJhoMoMV4,9431
 plotnine/scales/scale_identity.py,sha256=-PL9vJn0C_wOgrOQpqYSQbTWFSALoRPFzGXzebABTv8,2211
 plotnine/scales/scale_linetype.py,sha256=pwLTmglN6d4bnChbuBi6HWbDP_nsE4viXD8CK6XKBPw,1373
 plotnine/scales/scale_manual.py,sha256=oMnIfQNfxO4qw-gkBG3ikyuXdeoMgstRSdiibLc_DAA,4525
@@ -169,7 +170,7 @@ plotnine/stats/stat_bindot.py,sha256=FS-Axqhb-nMR9HK77BD-ElDHpsS8NaJKLMIff4-lDSU
 plotnine/stats/stat_boxplot.py,sha256=5PvTTig5kAZQjenYL-158tjnzRnRUcnJpJL5qOdv9WI,5997
 plotnine/stats/stat_count.py,sha256=P560-9Lm6FWUvL5bGASIBxY3vQnbcZrU4CYlBdZpE3Y,1928
 plotnine/stats/stat_density.py,sha256=1TyOIiAaOaZesPcqIsnaVk14by0cKu6b7d7r-a5ZZSI,10346
-plotnine/stats/stat_density_2d.py,sha256=fRpsnR7MiYKTDAw0CngDp5LE5wDsulz_PyX3g57UZcw,5686
+plotnine/stats/stat_density_2d.py,sha256=XSyE78IJwLLH4G5H7UD7ZrmknmaGCEMUHwvwNYmYVLQ,5647
 plotnine/stats/stat_ecdf.py,sha256=BdeisCWzDnuPMc3vBgZqpDsXCKy8ZfoSRwFPOQlgksM,1630
 plotnine/stats/stat_ellipse.py,sha256=NMr22TQMfVDZejIKvw1UWcB1NJptTlg6-qRf8d8EzJE,7570
 plotnine/stats/stat_function.py,sha256=AcP_wUu063fA8RAjc7AoFuVQmLdlsuEvP6m8AuTm9HY,3123
@@ -211,8 +212,8 @@ plotnine/themes/elements/element_line.py,sha256=xF6xW-iA66YEP_fN7ooqaYry8_8qZT-e
 plotnine/themes/elements/element_rect.py,sha256=w5cLH-Sr4cTRXVdkRiu8kBqFt3TXHhIb1MUITfi89gE,1767
 plotnine/themes/elements/element_text.py,sha256=8yhwBa9s9JKCtBcqcBNybbCGK6ieDnZv4SHiC4Sy2qc,6255
 plotnine/themes/elements/margin.py,sha256=jMHe-UKHHer_VYwAVDC-Tz2-AP_4YDuXPTWAuacoqgU,4080
-plotnine-0.15.0a3.dist-info/licenses/LICENSE,sha256=GY4tQiUd17Tq3wWR42Zs9MRTFOTf6ahIXhZTcwAdOeU,1082
-plotnine-0.15.0a3.dist-info/METADATA,sha256=E0dW-tEOB_1qHcqPrjENh9s63ew5YbVYgllwECO6_SI,9399
-plotnine-0.15.0a3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-plotnine-0.15.0a3.dist-info/top_level.txt,sha256=t340Mbko1ZbmvYPkQ81dIiPHcaQdTUszYz-bWUpr8ys,9
-plotnine-0.15.0a3.dist-info/RECORD,,
+plotnine-0.15.0a5.dist-info/licenses/LICENSE,sha256=GY4tQiUd17Tq3wWR42Zs9MRTFOTf6ahIXhZTcwAdOeU,1082
+plotnine-0.15.0a5.dist-info/METADATA,sha256=HJHt2oWR1vudsK80OUWXBGCkU_d_Q6TWUlvo2d9w-nQ,9407
+plotnine-0.15.0a5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+plotnine-0.15.0a5.dist-info/top_level.txt,sha256=t340Mbko1ZbmvYPkQ81dIiPHcaQdTUszYz-bWUpr8ys,9
+plotnine-0.15.0a5.dist-info/RECORD,,