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

plotnine/_mpl/layout_manager/_engine.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from matplotlib.figure import Figure
 
     from plotnine import ggplot
-    from plotnine.plot_composition import Compose
+    from plotnine.composition import Arrange
 
 
 class PlotnineLayoutEngine(LayoutEngine):
@@ -54,7 +54,7 @@ class PlotnineCompositionLayoutEngine(LayoutEngine):
     _adjust_compatible = True
     _colorbar_gridspec = False
 
-    def __init__(self, composition: Compose):
+    def __init__(self, composition: Arrange):
         self.composition = composition
 
     def execute(self, fig: Figure):

plotnine/_mpl/layout_manager/_layout_tree.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, cast
 
 import numpy as np
 
-from plotnine.plot_composition import OR
+from plotnine.composition import Beside
 
 from ._spaces import LayoutSpaces
 
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
     from plotnine import ggplot
     from plotnine._mpl.gridspec import p9GridSpec
-    from plotnine.plot_composition import Compose
+    from plotnine.composition import Arrange
 
 
 @dataclass
@@ -82,7 +82,7 @@ class LayoutTree:
 
     @staticmethod
     def create(
-        cmp: Compose,
+        cmp: Arrange,
         lookup_spaces: dict[ggplot, LayoutSpaces],
     ) -> LayoutTree:
         """
@@ -109,7 +109,7 @@ class LayoutTree:
             else:
                 nodes.append(LayoutTree.create(item, lookup_spaces))
 
-        if isinstance(cmp, OR):
+        if isinstance(cmp, Beside):
             return ColumnsTree(cmp.gridspec, nodes)
         else:
             return RowsTree(cmp.gridspec, nodes)

plotnine/_utils/__init__.py

@@ -1194,3 +1194,16 @@ def va_as_float(va: VerticalJustification | float) -> float:
         "center_baseline": 0.5,
     }
     return lookup[va] if isinstance(va, str) else va
+
+
+def has_alpha_channel(c: str | tuple) -> bool:
+    """
+    Return True if c a color with an alpha value
+
+    Either a 9 character hex string e.g. #AABBCC88 or
+    an RGBA tuple e.g. (.6, .7, .8, .5)
+    """
+    if isinstance(c, str):
+        return c.startswith("#") and len(c) == 9
+    else:
+        return color_utils.is_color_tuple(c) and len(c) == 4

plotnine/composition/__init__.py

@@ -0,0 +1,11 @@
+from ._arrange import Arrange
+from ._beside import Beside
+from ._plot_spacer import plot_spacer
+from ._stack import Stack
+
+__all__ = (
+    "Arrange",
+    "Stack",
+    "Beside",
+    "plot_spacer",
+)

plotnine/{plot_composition/_compose.py → composition/_arrange.py}

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import abc
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from io import BytesIO
 from typing import TYPE_CHECKING
 
@@ -24,9 +24,15 @@ if TYPE_CHECKING:
     from plotnine.ggplot import PlotAddable, ggplot
 
 
-class Compose:
+@dataclass
+class Arrange:
     """
-    Arrange two or more plots
+    Base class for those that create plot compositions
+
+    As a user, you will never directly work with this class, except
+    the operators [`|`](`plotnine.composition.Beside`) and
+    [`/`](`plotnine.composition.Stack`) that are powered by subclasses
+    of this class.
 
     Parameters
     ----------
@@ -34,27 +40,26 @@ class Compose:
         The objects to be put together (composed).
     """
 
-    def __init__(self, operands: list[ggplot | Compose]):
-        self.operands = operands
+    operands: list[ggplot | Arrange]
 
-        # These are created in the _create_figure method
-        self.figure: Figure
-        self.plotspecs: list[plotspec]
-        self.gridspec: p9GridSpec
+    # These are created in the _create_figure method
+    figure: Figure = field(init=False, repr=False)
+    plotspecs: list[plotspec] = field(init=False, repr=False)
+    gridspec: p9GridSpec = field(init=False, repr=False)
 
     @abc.abstractmethod
-    def __or__(self, rhs: ggplot | Compose) -> Compose:
+    def __or__(self, rhs: ggplot | Arrange) -> Arrange:
         """
         Add rhs as a column
         """
 
     @abc.abstractmethod
-    def __truediv__(self, rhs: ggplot | Compose) -> Compose:
+    def __truediv__(self, rhs: ggplot | Arrange) -> Arrange:
         """
         Add rhs as a row
         """
 
-    def __add__(self, rhs: ggplot | Compose | PlotAddable) -> Compose:
+    def __add__(self, rhs: ggplot | Arrange | PlotAddable) -> Arrange:
         """
         Add rhs to the composition
 
@@ -65,13 +70,13 @@ class Compose:
         """
         from plotnine import ggplot
 
-        if not isinstance(rhs, (ggplot, Compose)):
+        if not isinstance(rhs, (ggplot, Arrange)):
             cmp = deepcopy(self)
             cmp.last_plot = cmp.last_plot + rhs
             return cmp
         return self.__class__([*self, rhs])
 
-    def __sub__(self, rhs: ggplot | Compose) -> Compose:
+    def __sub__(self, rhs: ggplot | Arrange) -> Arrange:
         """
         Add the rhs besides the composition
 
@@ -82,7 +87,7 @@ class Compose:
         """
         return self.__class__([self, rhs])
 
-    def __and__(self, rhs: PlotAddable) -> Compose:
+    def __and__(self, rhs: PlotAddable) -> Arrange:
         """
         Add rhs to all plots in the composition
 
@@ -93,9 +98,9 @@ class Compose:
         """
         self = deepcopy(self)
 
-        def add_other(op: Compose):
+        def add_other(op: Arrange):
             for item in op:
-                if isinstance(item, Compose):
+                if isinstance(item, Arrange):
                     add_other(item)
                 else:
                     item += rhs
@@ -103,7 +108,7 @@ class Compose:
         add_other(self)
         return self
 
-    def __mul__(self, rhs: PlotAddable) -> Compose:
+    def __mul__(self, rhs: PlotAddable) -> Arrange:
         """
         Add rhs to the outermost nesting level of the composition
 
@@ -127,7 +132,7 @@ class Compose:
         """
         return len(self.operands)
 
-    def __iter__(self) -> Iterator[ggplot | Compose]:
+    def __iter__(self) -> Iterator[ggplot | Arrange]:
         """
         Return an iterable of all the operands
         """
@@ -227,7 +232,7 @@ class Compose:
         from plotnine._mpl.gridspec import p9GridSpec
 
         def _make_plotspecs(
-            cmp: Compose, parent_gridspec: p9GridSpec | None
+            cmp: Arrange, parent_gridspec: p9GridSpec | None
         ) -> Generator[plotspec]:
             """
             Return the plot specification for each subplot in the composition
@@ -289,7 +294,7 @@ class Compose:
 
     def draw(self, *, show: bool = False) -> Figure:
         """
-        Render the composed plots
+        Render the arranged plots
 
         Parameters
         ----------
@@ -315,9 +320,15 @@ class Compose:
             )
         return figure
 
-    def save(self, filename: str | Path | BytesIO, format: str | None = None):
+    def save(
+        self,
+        filename: str | Path | BytesIO,
+        format: str | None = None,
+        dpi: int | None = None,
+        **kwargs,
+    ):
         """
-        Save a Compose object as an image file
+        Save a composition as an image file
 
         Parameters
         ----------
@@ -326,14 +337,25 @@ class Compose:
         format :
             Image format to use, automatically extract from
             file name extension.
-        """
-        figure = self.draw()
+        dpi :
+            DPI to use for raster graphics. If None, defaults to using
+            the `dpi` of theme to the first plot.
+        kwargs :
+            These are ignored. Here to "softly" match the API of
+            `ggplot.save()`.
+        """
+        from plotnine import theme
+
+        # To set the dpi, we only need to change the dpi of
+        # the last plot and theme gets added to the last plot
+        plot = (self + theme(dpi=dpi)) if dpi else self
+        figure = plot.draw()
         figure.savefig(filename, format=format)
 
 
 @dataclass
 class plot_composition_context:
-    cmp: Compose
+    cmp: Arrange
     show: bool
 
     def __post_init__(self):
@@ -368,95 +390,3 @@ class plot_composition_context:
                 plt.close(self.cmp.figure)
 
         self._rc_context.__exit__(exc_type, exc_value, exc_traceback)
-
-
-class OR(Compose):
-    """
-    Compose by adding a column
-    """
-
-    @property
-    def nrow(self) -> int:
-        return 1
-
-    @property
-    def ncol(self) -> int:
-        return len(self)
-
-    def __or__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a column
-        """
-        # This is adjacent or i.e. (OR | rhs) so we collapse the
-        # operands into a single operation
-        return OR([*self, rhs])
-
-    def __truediv__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a row
-        """
-        return DIV([self, rhs])
-
-
-class DIV(Compose):
-    """
-    Compose by adding a row
-    """
-
-    @property
-    def nrow(self) -> int:
-        return len(self)
-
-    @property
-    def ncol(self) -> int:
-        return 1
-
-    def __truediv__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a row
-        """
-        # This is an adjacent div i.e. (DIV | rhs) so we collapse the
-        # operands into a single operation
-        return DIV([*self, rhs])
-
-    def __or__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a column
-        """
-        return OR([self, rhs])
-
-
-class ADD(Compose):
-    """
-    Compose by adding
-    """
-
-    @property
-    def nrow(self) -> int:
-        from plotnine.facets.facet_wrap import wrap_dims
-
-        return wrap_dims(len(self))[0]
-
-    @property
-    def ncol(self) -> int:
-        from plotnine.facets.facet_wrap import wrap_dims
-
-        return wrap_dims(len(self))[1]
-
-    def __or__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a column
-        """
-        return OR([self, rhs])
-
-    def __truediv__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a row
-        """
-        return DIV([self, rhs])
-
-    def __sub__(self, rhs: ggplot | Compose) -> Compose:
-        """
-        Add rhs as a column
-        """
-        return OR([self, rhs])

plotnine/composition/_beside.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._arrange import Arrange
+
+if TYPE_CHECKING:
+    from plotnine.ggplot import ggplot
+
+
+class Beside(Arrange):
+    """
+    Place plots or compositions side by side
+
+    **Usage**
+
+        plot | plot
+        plot | composition
+        composition | plot
+        composition | composition
+
+    Typically, you will use this class through the `|` operator.
+    """
+
+    @property
+    def nrow(self) -> int:
+        return 1
+
+    @property
+    def ncol(self) -> int:
+        return len(self)
+
+    def __or__(self, rhs: ggplot | Arrange) -> Arrange:
+        """
+        Add rhs as a column
+        """
+        # This is adjacent or i.e. (OR | rhs) so we collapse the
+        # operands into a single operation
+        return Beside([*self, rhs])
+
+    def __truediv__(self, rhs: ggplot | Arrange) -> Arrange:
+        """
+        Add rhs as a row
+        """
+        from ._stack import Stack
+
+        return Stack([self, rhs])

plotnine/composition/_plot_spacer.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from copy import deepcopy
+
+from plotnine import element_rect, ggplot, theme, theme_void
+
+
+class plot_spacer(ggplot):
+    """
+    Blank area as wide or as tall as a plot
+
+    Parameters
+    ----------
+    fill :
+        Background color. The default is a transparent area, but it
+        can be changed through this parameter.
+
+        The color can also be modified by adding a [](`~plotnine.theme`)
+        and setting the [](`~plotnine.themes.themeable.plot_background`).
+    """
+
+    def __init__(
+        self,
+        fill: (
+            str
+            | tuple[float, float, float]
+            | tuple[float, float, float, float]
+            | None
+        ) = None,
+    ):
+        super().__init__()
+        self.theme = theme_void()
+        if fill:
+            self.theme += theme(plot_background=element_rect(fill=fill))
+
+    def __add__(self, rhs) -> plot_spacer:
+        """
+        Add to spacer
+
+        All added objects are no ops except the `plot_background` in
+        in a theme.
+        """
+        self = deepcopy(self)
+        if isinstance(rhs, theme):
+            fill = rhs.getp(("plot_background", "facecolor"))
+            self.theme += theme(
+                plot_background=element_rect(fill=fill),
+            )
+        return self

plotnine/composition/_stack.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._arrange import Arrange
+
+if TYPE_CHECKING:
+    from plotnine.ggplot import ggplot
+
+
+class Stack(Arrange):
+    """
+    Place plots or compositions on top of each other
+
+    **Usage**
+
+        plot / plot
+        plot / composition
+        composition / plot
+        composition / composition
+
+    Typically, you will use this class through the `/` operator.
+    """
+
+    @property
+    def nrow(self) -> int:
+        return len(self)
+
+    @property
+    def ncol(self) -> int:
+        return 1
+
+    def __truediv__(self, rhs: ggplot | Arrange) -> Arrange:
+        """
+        Add rhs as a row
+        """
+        # This is an adjacent div i.e. (DIV | rhs) so we collapse the
+        # operands into a single operation
+        return Stack([*self, rhs])
+
+    def __or__(self, rhs: ggplot | Arrange) -> Arrange:
+        """
+        Add rhs as a column
+        """
+        from ._beside import Beside
+
+        return Beside([self, rhs])

plotnine/geoms/geom.py

@@ -2,9 +2,12 @@ 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,
     remove_missing,
@@ -12,7 +15,7 @@ from .._utils import (
 from .._utils.registry import Register, Registry
 from ..exceptions import PlotnineError
 from ..layer import layer
-from ..mapping.aes import RepeatAesthetic, rename_aesthetics
+from ..mapping.aes import rename_aesthetics
 from ..mapping.evaluation import evaluate
 from ..positions.position import position
 from ..stats.stat import stat
@@ -243,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()
@@ -261,25 +267,31 @@ class geom(ABC, metaclass=Register):
         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
-            except ValueError as e:
-                # NOTE: Handling of the edgecases in this exception is not
-                # foolproof.
-                repeat_ae = getattr(RepeatAesthetic, ae, None)
-                if across_panels:
-                    # Adding an annotation/abline/hline/vhline with multiple
-                    # items across to more than 1 panel
-                    value = list(chain(*repeat(value, num_panels)))
+            elif isinstance(value, ae_value):
+                data[ae] = value * len(data)
+            elif across_panels:
+                value = list(chain(*repeat(value, num_panels)))
+                data[ae] = value
+            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
-                elif repeat_ae:
-                    # Some aesthetics may have valid values that are not
-                    # scalar. e.g. sequences. For such case, we need to
-                    # insert a sequence of the same value.
-                    data[ae] = repeat_ae(value, len(data))
-                else:
+                except ValueError as e:
                     msg = f"'{ae}={value}' does not look like a valid value"
                     raise PlotnineError(msg) from e
 

plotnine/geoms/geom_area.py

@@ -14,12 +14,12 @@ class geom_area(geom_ribbon):
     """
     Area plot
 
+    {usage}
+
     An area plot is a special case of geom_ribbon,
     where the minimum of the range is fixed to 0,
     and the position adjustment defaults to 'stack'.
 
-    {usage}
-
     Parameters
     ----------
     {common_parameters}

plotnine/geoms/geom_bin_2d.py

@@ -7,13 +7,13 @@ class geom_bin_2d(geom_rect):
     """
     Heatmap of 2d bin counts
 
+    {usage}
+
     Divides the plane into rectangles, counts the number of
     cases in each rectangle, and then (by default) maps the number
     of cases to the rectangle's fill. This is a useful alternative
     to geom_point in the presence of overplotting.
 
-    {usage}
-
     Parameters
     ----------
     {common_parameters}

plotnine/geoms/geom_col.py

@@ -7,13 +7,13 @@ class geom_col(geom_bar):
     """
     Bar plot with base on the x-axis
 
+    {usage}
+
     This is an alternate version of [](`~plotnine.geoms.geom_bar`) that maps
     the height of bars to an existing variable in your data. If
     you want the height of the bar to represent a count of cases,
     use [](`~plotnine.geoms.geom_bar`).
 
-    {usage}
-
     Parameters
     ----------
     {common_parameters}

plotnine/geoms/geom_count.py

@@ -7,12 +7,12 @@ class geom_count(geom_point):
     """
     Plot overlapping points
 
+    {usage}
+
     This is a variant [](`~plotnine.geoms.geom_point`) that counts the number
     of observations at each location, then maps the count to point
     area. It useful when you have discrete data and overplotting.
 
-    {usage}
-
     Parameters
     ----------
     {common_parameters}

plotnine/geoms/geom_density_2d.py

@@ -7,10 +7,10 @@ class geom_density_2d(geom_path):
     """
     2D density estimate
 
-    This is a 2d version of [](`~plotnine.geoms.geom_density`).
-
     {usage}
 
+    This is a 2d version of [](`~plotnine.geoms.geom_density`).
+
     Parameters
     ----------
     {common_parameters}

plotnine/geoms/geom_map.py

@@ -33,10 +33,10 @@ class geom_map(geom):
     """
     Draw map feature
 
-    The map feature are drawn without any special projections.
-
     {usage}
 
+    The map feature are drawn without any special projections.
+
     Parameters
     ----------
     {common_parameters}

plotnine/geoms/geom_sina.py

@@ -7,13 +7,13 @@ class geom_sina(geom_point):
     """
     Draw a sina plot
 
+    {usage}
+
     A sina plot is a data visualization chart suitable for plotting
     any single variable in a multiclass dataset. It is an enhanced
     jitter strip chart, where the width of the jitter is controlled
     by the density distribution of the data within each class.
 
-    {usage}
-
     Parameters
     ----------
     {common_parameters}

plotnine/ggplot.py

@@ -13,7 +13,6 @@ from typing import (
     Iterable,
     Optional,
     cast,
-    overload,
 )
 from warnings import warn
 
@@ -53,10 +52,10 @@ if TYPE_CHECKING:
 
     from plotnine import watermark
     from plotnine._mpl.gridspec import p9GridSpec
+    from plotnine.composition import Arrange
     from plotnine.coords.coord import coord
     from plotnine.facets.facet import facet
     from plotnine.layer import layer
-    from plotnine.plot_composition import Compose
     from plotnine.typing import DataLike
 
     class PlotAddable(Protocol):
@@ -230,18 +229,10 @@ class ggplot:
             other.__radd__(self)
         return self
 
-    @overload
-    def __add__(
-        self, rhs: PlotAddable | list[PlotAddable] | None
-    ) -> ggplot: ...
-
-    @overload
-    def __add__(self, rhs: ggplot | Compose) -> Compose: ...
-
     def __add__(
         self,
-        rhs: PlotAddable | list[PlotAddable] | None | ggplot | Compose,
-    ) -> ggplot | Compose:
+        rhs: PlotAddable | list[PlotAddable] | None,
+    ) -> ggplot:
         """
         Add to ggplot
 
@@ -251,37 +242,32 @@ class ggplot:
             Either an object that knows how to "radd"
             itself to a ggplot, or a list of such objects.
         """
-        from .plot_composition import ADD, Compose
-
-        if isinstance(rhs, (ggplot, Compose)):
-            return ADD([self, rhs])
-
         self = deepcopy(self)
         return self.__iadd__(rhs)
 
-    def __or__(self, rhs: ggplot | Compose) -> Compose:
+    def __or__(self, rhs: ggplot | Arrange) -> Arrange:
         """
         Compose 2 plots columnwise
         """
-        from .plot_composition import OR
+        from .composition import Beside
 
-        return OR([self, rhs])
+        return Beside([self, rhs])
 
-    def __truediv__(self, rhs: ggplot | Compose) -> Compose:
+    def __truediv__(self, rhs: ggplot | Arrange) -> Arrange:
         """
         Compose 2 plots rowwise
         """
-        from .plot_composition import DIV
+        from .composition import Stack
 
-        return DIV([self, rhs])
+        return Stack([self, rhs])
 
-    def __sub__(self, rhs: ggplot | Compose) -> Compose:
+    def __sub__(self, rhs: ggplot | Arrange) -> Arrange:
         """
         Compose 2 plots columnwise
         """
-        from .plot_composition import OR
+        from .composition import Beside
 
-        return OR([self, rhs])
+        return Beside([self, rhs])
 
     def __rrshift__(self, other: DataLike) -> ggplot:
         """

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/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
@@ -29,6 +30,7 @@ class _scale_manual(scale_discrete):
             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))
 

plotnine/themes/elements/element_line.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from .element_base import element_base
 
 if TYPE_CHECKING:
-    from typing import Any, Literal, Optional, Sequence
+    from typing import Any, Literal, Sequence
 
 
 class element_line(element_base):
@@ -26,6 +26,8 @@ class element_line(element_base):
         using tuples, see [](`~matplotlib.lines.line2D.set_linestyle`).
     size : float
         line thickness
+    alpha : float
+        Opacity value
     kwargs : dict
         Parameters recognised by [](`~matplotlib.lines.line2d`).
     """
@@ -33,31 +35,37 @@ class element_line(element_base):
     def __init__(
         self,
         *,
-        color: Optional[
+        color: (
             str
             | tuple[float, float, float]
             | tuple[float, float, float, float]
-        ] = None,
-        size: Optional[float] = None,
-        linetype: Optional[str | Sequence[int]] = None,
-        lineend: Optional[Literal["butt", "projecting", "round"]] = None,
-        colour: Optional[
+            | None
+        ) = None,
+        size: float | None = None,
+        linetype: str | Sequence[int] | None = None,
+        lineend: Literal["butt", "projecting", "round"] | None = None,
+        colour: (
             str
             | tuple[float, float, float]
             | tuple[float, float, float, float]
-        ] = None,
+            | None
+        ) = None,
+        alpha: float | None = None,
         **kwargs: Any,
     ):
         super().__init__()
         self.properties.update(**kwargs)
 
-        color = color if color else colour
+        color = color if color is not None else colour
+
         if color:
             self.properties["color"] = color
         if size:
             self.properties["linewidth"] = size
         if linetype:
             self.properties["linestyle"] = linetype
+        if alpha is not None:
+            self.properties["alpha"] = alpha
 
         if linetype in ("solid", "-") and lineend:
             self.properties["solid_capstyle"] = lineend

plotnine/themes/themeable.py

@@ -17,7 +17,7 @@ from warnings import warn
 
 import numpy as np
 
-from .._utils import to_rgba
+from .._utils import has_alpha_channel, to_rgba
 from .._utils.registry import RegistryHierarchyMeta
 from ..exceptions import PlotnineError, deprecated_themeable_name
 from .elements import element_blank
@@ -504,6 +504,25 @@ class MixinSequenceOfValues(themeable):
                 a.set(**{name: value})
 
 
+def blend_alpha(
+    properties: dict[str, Any], key: str = "color"
+) -> dict[str, Any]:
+    """
+    Blend color with alpha
+
+    When setting color property values of matplotlib objects,
+    for a color with an alpha channel, we don't want the alpha
+    property if any to have any effect on that color.
+    """
+    if (color := properties.get(key)) is not None:
+        if "alpha" in properties:
+            properties[key] = to_rgba(color, properties["alpha"])
+            properties["alpha"] = None
+        elif has_alpha_channel(color):
+            properties["alpha"] = None
+    return properties
+
+
 # element_text themeables
 
 
@@ -1366,7 +1385,7 @@ class panel_grid_major_x(themeable):
 
     def apply_ax(self, ax: Axes):
         super().apply_ax(ax)
-        ax.xaxis.grid(which="major", **self.properties)
+        ax.xaxis.grid(which="major", **blend_alpha(self.properties))
 
     def blank_ax(self, ax: Axes):
         super().blank_ax(ax)
@@ -1384,7 +1403,7 @@ class panel_grid_major_y(themeable):
 
     def apply_ax(self, ax: Axes):
         super().apply_ax(ax)
-        ax.yaxis.grid(which="major", **self.properties)
+        ax.yaxis.grid(which="major", **blend_alpha(self.properties))
 
     def blank_ax(self, ax: Axes):
         super().blank_ax(ax)
@@ -1612,11 +1631,7 @@ class panel_background(legend_key):
 
     def apply_ax(self, ax: Axes):
         super().apply_ax(ax)
-        d = self.properties
-        if "facecolor" in d and "alpha" in d:
-            d["facecolor"] = to_rgba(d["facecolor"], d["alpha"])
-            del d["alpha"]
-
+        d = blend_alpha(self.properties, "facecolor")
         d["edgecolor"] = "none"
         d["linewidth"] = 0
         ax.patch.set(**d)
@@ -1642,16 +1657,12 @@ class panel_border(MixinSequenceOfValues):
         if not (rects := targets.panel_border):
             return
 
-        d = self.properties
+        d = blend_alpha(self.properties, "edgecolor")
 
         with suppress(KeyError):
             if d["edgecolor"] == "none" or d["size"] == 0:
                 return
 
-        if "edgecolor" in d and "alpha" in d:
-            d["edgecolor"] = to_rgba(d["edgecolor"], d["alpha"])
-            del d["alpha"]
-
         self.set(rects, d)
 
     def blank_figure(self, figure: Figure, targets: ThemeTargets):

{plotnine-0.15.0a4.dist-info → plotnine-0.15.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotnine
-Version: 0.15.0a4
+Version: 0.15.0a6
 Summary: A Grammar of Graphics for Python
 Author-email: Hassan Kibirige <has2k1@gmail.com>
 License: The MIT License (MIT)

{plotnine-0.15.0a4.dist-info → plotnine-0.15.0a6.dist-info}/RECORD

@@ -2,7 +2,7 @@ plotnine/__init__.py,sha256=HrJhd65bnny1t-TawUgvApVj4p-gDZ0ftpr2NKZeW_s,10316
 plotnine/animation.py,sha256=izJZ4Gy0cBHEBc8ehofsWSWOzZW8UEroy1Uvw86Igb0,7521
 plotnine/doctools.py,sha256=JBF55q1MX2fXYQcGDpVrGPdlKf5OiQ5gyTdWhnM_IzU,14558
 plotnine/exceptions.py,sha256=SgTxBHkV65HjGI3aFy2q1_lHP9HAdiuxVLN3U-PJWSQ,1616
-plotnine/ggplot.py,sha256=xFj9iWAyBvnhitCrpgdNonQIqqjBQ2aDgkqpvHbH364,24823
+plotnine/ggplot.py,sha256=Nl41v1zRUulyIBMzrzIE4IgIrHU0bicL2YH4x01wHt8,24457
 plotnine/helpers.py,sha256=4R3KZmtGH46-kRNSGOA0JxZaLKBo0ge8Vnx1cDQ8_gI,966
 plotnine/iapi.py,sha256=jNLmUSoh5g9kNdhOoXSqNcqOdd2-6xdWAmst-YGU41U,9095
 plotnine/labels.py,sha256=3pOXth2Xma_qCqB_xXAGIkPQ9gcaUaaFEAsa5if1iR0,2830
@@ -21,17 +21,23 @@ plotnine/_mpl/ticker.py,sha256=RY_7AdTggc7QBq9_t0KBJXg36oxKfB-Vtc9FzLnaGnQ,393
 plotnine/_mpl/transforms.py,sha256=DNaOlNq76xlT696sN8ot1bmYyp4mmrjXQHk3kTi4HIg,76
 plotnine/_mpl/utils.py,sha256=0GY3CWWXZiNHe333v9GAquRe5naO54JeiPt67-UvVYw,4147
 plotnine/_mpl/layout_manager/__init__.py,sha256=IXpPF5Oycc45uFpK4MJ6kcQCe1u5VUfnHLNZGcnrJCg,157
-plotnine/_mpl/layout_manager/_engine.py,sha256=ESUvbLAlZApFbBi6w7gZA7S4guS0Rmrj-us-gzYP2ZM,2809
+plotnine/_mpl/layout_manager/_engine.py,sha256=m6FDFc1XELfzNSIXaFiN3ruoTgub2PaV3wPQWP0IBYE,2804
 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/_layout_tree.py,sha256=yFNt7fsv2VhEt3261OfLP7kgPYNd_npLoNDLp_QJi3Y,26445
 plotnine/_mpl/layout_manager/_spaces.py,sha256=ahBpKt-q1kVOTGiGliwl_DNB6pTEekAzA_7-GXwFlBk,35789
-plotnine/_utils/__init__.py,sha256=czHi-uv4eIBCDf6td11bGA41PMXaJ5j7t-avx_JbYgY,30636
+plotnine/_utils/__init__.py,sha256=3tcSTng6Mtk1o6NPEikALHKD3ZGuAYofjQJREHX84a4,30992
 plotnine/_utils/context.py,sha256=HPQy_uyNXdS0s9URD7ZePyuc5hFU2XrRBLDTqRDLJzY,1708
 plotnine/_utils/dev.py,sha256=0qgRbMhcd4dfuLuYxx0skocKAtfwHF02ntyILRBogbg,1629
 plotnine/_utils/ipython.py,sha256=5Obr73xJ-4dzJEdBrFA8z9TXuxY7pIjKmzdTzWwnxNk,1884
 plotnine/_utils/quarto.py,sha256=bwbU3ork8wuUIW5VDJ73J_DbWWzpYWpAd76cHMzCRao,890
 plotnine/_utils/registry.py,sha256=HoiB2NnbEHufXjYnVJyrJKflk2RwKtTYk2L3n7tH4XA,3321
 plotnine/_utils/yippie.py,sha256=DbmxvVrd34P24CCmOZrAulyGQ35rXNaSr8BuutS2Uio,2392
+plotnine/composition/__init__.py,sha256=WXkLaqbgpOquCbq_hakUUQlcIka9fN0IMKNm-DOns6E,198
+plotnine/composition/_arrange.py,sha256=-ZPe3JydfVAvVYiTI0W7aJaUySonpE2o76aKaxfjS84,11040
+plotnine/composition/_beside.py,sha256=DAMZfIrOfz4mQSqro22GpooaCnm8ns6lG6vIp8SnAtg,993
+plotnine/composition/_plot_spacer.py,sha256=gjAymmjOVZwwT0Y01MqHA3tAEDAr0mcWSX07npzo1Hw,1298
+plotnine/composition/_plotspec.py,sha256=0F7q7PjDMDqcallpnBdX3N2iSRjdBTyjSvMFf83uvPU,1015
+plotnine/composition/_stack.py,sha256=TXvy8FQ7CNNzntkjz4h4R_6-LxYSNFF5ri9E82dv17Q,1007
 plotnine/coords/__init__.py,sha256=inM-9JwSPvYLlOy6opye0YV2EGWsI4708wGKdHvQvVM,301
 plotnine/coords/coord.py,sha256=Yu2xj4BqFBWlS0XHNDa6h8Dek0_PA6Lssv3M9EneSB8,6883
 plotnine/coords/coord_cartesian.py,sha256=vGeSFe9UyycUkbjdjoPNSQJwnnU7fEmsk0nl_oBvzxY,3038
@@ -69,18 +75,18 @@ plotnine/geoms/__init__.py,sha256=HEfhNmmNH4xm4rpXnFRXY4eLkJha3XPM72IIwVjv5Lc,26
 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=cjxzWTZiAMop9FuXWg5kqgo1lBEG2Uu6DzARjHOpBY4,17300
+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_area.py,sha256=QtS9NO17v-i5gvfakN8L96xwjt3dFuyZdYN8oXaXWOY,818
 plotnine/geoms/geom_bar.py,sha256=SnqS4hPTfqXzdPh1U-kNuBg0LNX9_tQC9OKhIlB7cy0,1732
-plotnine/geoms/geom_bin_2d.py,sha256=b2fAQVywug-ey3KtqeOoYQ2RNRSRE_fa4s7M41W-_FE,574
+plotnine/geoms/geom_bin_2d.py,sha256=IhlpR62o4Y6qe-tNUywOMjhseJNPV3c-x2QB6D11EPU,574
 plotnine/geoms/geom_blank.py,sha256=38BpE9iSh3ktbOe9ayNer6IDD1q7E4EiKS_KnFSko0c,770
 plotnine/geoms/geom_boxplot.py,sha256=OISXd3CCuH06sKqOB8xlfUPrwUX_FUKQauSqE7L-PhQ,9778
-plotnine/geoms/geom_col.py,sha256=sGZZzkXgwlgI2D-M1UE1QAWsWZqtP1z8R0HjrnW9hkY,1187
-plotnine/geoms/geom_count.py,sha256=IRIlQqwt0kIHf9swYZbFqd5RSQCYRyFKm5hp1C9xHB4,511
+plotnine/geoms/geom_col.py,sha256=KCpme3vsc_tTbjGvL7ZhJZ4KFrQDQw3K8JyO6EBFn4E,1187
+plotnine/geoms/geom_count.py,sha256=4quwvXQSrdDdlQfaSRmkBzpEP6qCRPB9SS6_5UV037M,511
 plotnine/geoms/geom_crossbar.py,sha256=0NGUY4fhL8VxpGaBgjKQNJy85XJeLc6GiPCs5LZQuCc,6242
 plotnine/geoms/geom_density.py,sha256=UwUkJxI79L3z19tmoSI6ZYs418XTbRznd-Abzrec3VY,526
-plotnine/geoms/geom_density_2d.py,sha256=V37QYpdZpZvYxishlN1UBmyyRC3U2eOqR-gaIPxQqS4,400
+plotnine/geoms/geom_density_2d.py,sha256=xEtQTTQnBzOs5PMDViZNQoSiXduU93SGmTN0u77RPj4,400
 plotnine/geoms/geom_dotplot.py,sha256=ZHmRCEGS3Nv2tiNwALBC7ewBg1prcb_FOxAImTGKP3c,8680
 plotnine/geoms/geom_errorbar.py,sha256=jpCuQ8CE2RKfRR8Aw_3s473HXrOk-WPOl46n4oC-8UI,2199
 plotnine/geoms/geom_errorbarh.py,sha256=mgRo8KngGyKVSPPF8vUYlzdslBJEIe9QJC--DlWL5t4,2213
@@ -91,7 +97,7 @@ plotnine/geoms/geom_jitter.py,sha256=mJCLt2SoZN_tx_3XS8oF5JojtL2m5HO1bEqdN-JEPUg
 plotnine/geoms/geom_label.py,sha256=lPxmDlS6VgEHqD3Ac1Q-Zxs75JcnduoXjJ_D1AzzWew,2835
 plotnine/geoms/geom_line.py,sha256=IzKVPwF_Oe3uwRpuh5Xu9LFvz0XcKqCL4pN03iGHBdk,522
 plotnine/geoms/geom_linerange.py,sha256=dkgQ28YZfjyMb_y8s0wfcAz5mHF7f7y_h1Den5wHyJk,1282
-plotnine/geoms/geom_map.py,sha256=E2DVSMx9-8-4duCUOd-4n-Lqu_VDL5qzQrt2PCLkMzY,9602
+plotnine/geoms/geom_map.py,sha256=tvzFVNOtSOfof1NQFduB8SV143o2irNsQrM8BgYiEKU,9602
 plotnine/geoms/geom_path.py,sha256=nDrlmqPn869vyUF4RYbLKkbQka14SWJu9pqCN-cdKbQ,17106
 plotnine/geoms/geom_point.py,sha256=KWM511zxIpKQzxI_NJpFqEszNWg5E7iHZJylKvvaK2c,4607
 plotnine/geoms/geom_pointdensity.py,sha256=TKaxAUPwdrVMw0MVYe14apBsRfW_5_zXFLSlOS60Zlw,372
@@ -105,7 +111,7 @@ plotnine/geoms/geom_rect.py,sha256=dGOAkVXf5NSJgIbaVezg1ac78GqimElB9Ua0L_SH_YM,3
 plotnine/geoms/geom_ribbon.py,sha256=af9uElWaJQSc4taTLZ7ZDzng2Zw4IrIfNPrus4OuTmM,5771
 plotnine/geoms/geom_rug.py,sha256=2Sdarf5z3w4JbklVUk7JykWdbBNKaT0Wl5NMBl4LqT4,3520
 plotnine/geoms/geom_segment.py,sha256=v63MoKlK4aNengCXYdPeQrcBIgBCis8QobpF3CJOf5U,3052
-plotnine/geoms/geom_sina.py,sha256=oyCiBCdsWjrSNaS2jOpu0Ng8nEl_peaCT-EuHE9jG34,912
+plotnine/geoms/geom_sina.py,sha256=JspG0o_K4px0KKZVaVeuBnk0iGjVJnB9PGjt8UAf08I,912
 plotnine/geoms/geom_smooth.py,sha256=8jSxQFTdoo7RmeTrGl2j-iE6lfydUPitz-dKvxKk0Kw,3545
 plotnine/geoms/geom_spoke.py,sha256=s-kug0H-YGhyjso9W43XvzJf9-g6inh8zzuSFeXzSaU,977
 plotnine/geoms/geom_step.py,sha256=tTohADfGyC3M4zCzxLUhzkA2XsHBeH0eaWq-m2DQEQQ,2371
@@ -120,14 +126,11 @@ 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=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
-plotnine/plot_composition/_plotspec.py,sha256=0F7q7PjDMDqcallpnBdX3N2iSRjdBTyjSvMFf83uvPU,1015
-plotnine/plot_composition/_spacer.py,sha256=vaC4F5tHhvL7T7Ns9zxUbytqwB6MLNhm5jtiKG0vAiU,798
 plotnine/positions/__init__.py,sha256=DQZE6duMUNRQifpa6SBrOKxZpGDk4NqQSGZLr9Yc9GI,595
 plotnine/positions/position.py,sha256=BRD_dUh9dhdSP4SQfl8_u_VpaY_s3A2zuznwOn5M_80,8325
 plotnine/positions/position_dodge.py,sha256=6PbAhWDfNK7NK6FZZOcfr4mdmVOUV9VLH8xD0dbQFEU,3941
@@ -151,7 +154,7 @@ plotnine/scales/scale_datetime.py,sha256=OM9gfHKGkQIBrgqCEE00zUV0cMXXxTIS7wc9dYQ
 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
+plotnine/scales/scale_manual.py,sha256=FmzF4gRxdiDVgryodN2Mx6Gr1FHW0grKO3WiL1ffkTc,4609
 plotnine/scales/scale_shape.py,sha256=I0JdYDreCbznQilaTi6m27F91N5daCj9D2ZPuP2Szls,2081
 plotnine/scales/scale_size.py,sha256=04nUQzKB_qpuQrcg8C7jYmLDYtdnlg6PkY7SivP5OlY,3273
 plotnine/scales/scale_stroke.py,sha256=7LKAg6-Q3VTuw78N2XEjFFzBa8yY5NVnfBSoJGsBS5o,1711
@@ -203,16 +206,16 @@ plotnine/themes/theme_seaborn.py,sha256=8giJh8QvkMJ8pr_XXHPDMfkysoI2_yr0vJhz48_s
 plotnine/themes/theme_tufte.py,sha256=qUOrZhQyfJgc0fmy8Es7tT7aYqUSzCjvkP7-dBilwHE,1926
 plotnine/themes/theme_void.py,sha256=gYXr367zYNhvt_NXlDUx0rBPUYJa1F6adnANn5HEx5A,3407
 plotnine/themes/theme_xkcd.py,sha256=5MOdj_H23Kr_jbDnepmq1DQDbn8-TfUmtzYBZTb4RB4,2207
-plotnine/themes/themeable.py,sha256=aMm5MxbsmEV1XX87AFPPBfAgkJP3Vm0_z9_tKZwsxxY,71321
+plotnine/themes/themeable.py,sha256=Px91yh5pft24mC-4uUFLYpU-45iX6cE64j3t-a20wug,71744
 plotnine/themes/elements/__init__.py,sha256=xV1la_mTv1BQ3zQp7ZGVGPdV6KohvEVhKAi1uPTeAs0,327
 plotnine/themes/elements/element_base.py,sha256=D7cfEglzsSuhW91KpZVAZ2MAHWZp64r9Aajoh8uMGZ4,832
 plotnine/themes/elements/element_blank.py,sha256=4r7-6HeR1494oWNIGQh0ASrFQ4SLvYa6aQHA85eH-Ds,187
-plotnine/themes/elements/element_line.py,sha256=xF6xW-iA66YEP_fN7ooqaYry8_8qZT-eT5wvKwXg3to,1838
+plotnine/themes/elements/element_line.py,sha256=yZvj9B3M2a7a8o2J0n-q0uviNv34PtJVUr_UefZ-v5I,2005
 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.0a4.dist-info/licenses/LICENSE,sha256=GY4tQiUd17Tq3wWR42Zs9MRTFOTf6ahIXhZTcwAdOeU,1082
-plotnine-0.15.0a4.dist-info/METADATA,sha256=MCVzMIfRSdwYyq2UrgdS74Zc8QiMo9pp8GiwCVFZXCo,9407
-plotnine-0.15.0a4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-plotnine-0.15.0a4.dist-info/top_level.txt,sha256=t340Mbko1ZbmvYPkQ81dIiPHcaQdTUszYz-bWUpr8ys,9
-plotnine-0.15.0a4.dist-info/RECORD,,
+plotnine-0.15.0a6.dist-info/licenses/LICENSE,sha256=GY4tQiUd17Tq3wWR42Zs9MRTFOTf6ahIXhZTcwAdOeU,1082
+plotnine-0.15.0a6.dist-info/METADATA,sha256=FDNoeUumEK4SXTfxin727GT3RL94ky46x9L5e5fNQ-g,9407
+plotnine-0.15.0a6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+plotnine-0.15.0a6.dist-info/top_level.txt,sha256=t340Mbko1ZbmvYPkQ81dIiPHcaQdTUszYz-bWUpr8ys,9
+plotnine-0.15.0a6.dist-info/RECORD,,

plotnine/plot_composition/__init__.py

@@ -1,10 +0,0 @@
-from ._compose import ADD, DIV, OR, Compose
-from ._spacer import spacer
-
-__all__ = (
-    "Compose",
-    "ADD",
-    "DIV",
-    "OR",
-    "spacer",
-)

plotnine/plot_composition/_spacer.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from copy import deepcopy
-
-from plotnine import element_rect, ggplot, theme, theme_void
-
-
-class spacer(ggplot):
-    """
-    An empty plot
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.theme = theme_void()
-
-    def __add__(self, rhs) -> spacer:  # pyright: ignore[reportIncompatibleMethodOverride]
-        """
-        Add to spacer
-
-        All added objects are no ops except the plot_background,
-        i.e.:
-
-            theme(plot_background=element_rect(fill="red"))
-        """
-        self = deepcopy(self)
-        if isinstance(rhs, theme):
-            fill = rhs.getp(("plot_background", "facecolor"))
-            self.theme += theme(
-                plot_background=element_rect(fill=fill),
-            )
-        return self