plotnine 0.14.5__py3-none-any.whl → 0.15.0a2__py3-none-any.whl

plotnine/scales/scale_identity.py

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

plotnine/scales/scale_manual.py

@@ -21,11 +21,15 @@ class _scale_manual(scale_discrete):
     """
 
     def __post_init__(self, values):
-        from collections.abc import Sized
+        from collections.abc import Iterable, Sized
 
         super().__post_init__()
 
-        if isinstance(self.breaks, Sized) and len(self.breaks) == len(values):
+        if (
+            isinstance(self.breaks, Iterable)
+            and isinstance(self.breaks, Sized)
+            and len(self.breaks) == len(values)
+        ):
             values = dict(zip(self.breaks, values))
 
         def palette(n):

plotnine/stats/binning.py

@@ -73,7 +73,7 @@ def breaks_from_binwidth(
 
     if boundary is not None and center is not None:
         raise PlotnineError(
-            "Only one of 'boundary' and 'center' " "may be specified."
+            "Only one of 'boundary' and 'center' may be specified."
         )
     elif boundary is None:
         # When center is None, put the min and max of data in outer
@@ -165,7 +165,10 @@ def assign_bins(
     if weight is None:
         weight = np.ones(len(x))
     else:
-        weight = np.asarray(weight)
+        # If weight is a dtype that isn't writeable
+        # and does not own it's memory. Using a list
+        # as an intermediate easily solves this.
+        weight = np.array(list(weight))
         weight[np.isnan(weight)] = 0
 
     bin_idx = pd.cut(

plotnine/stats/smoothers.py

@@ -37,7 +37,7 @@ def predictdf(data, xseq, **params) -> pd.DataFrame:
         "gpr": gpr,
     }
 
-    method = cast(str | Callable[..., pd.DataFrame], params["method"])
+    method = cast("str | Callable[..., pd.DataFrame]", params["method"])
 
     if isinstance(method, str):
         try:
@@ -163,8 +163,7 @@ def rlm(data, xseq, **params) -> pd.DataFrame:
 
     if params["se"]:
         warnings.warn(
-            "Confidence intervals are not yet implemented"
-            " for RLM smoothing.",
+            "Confidence intervals are not yet implemented for RLM smoothing.",
             PlotnineWarning,
         )
 
@@ -190,8 +189,7 @@ def rlm_formula(data, xseq, **params) -> pd.DataFrame:
 
     if params["se"]:
         warnings.warn(
-            "Confidence intervals are not yet implemented"
-            " for RLM smoothing.",
+            "Confidence intervals are not yet implemented for RLM smoothing.",
             PlotnineWarning,
         )
 

plotnine/stats/stat.py

@@ -392,7 +392,7 @@ class stat(ABC, metaclass=Register):
         msg = "{} should implement this method."
         raise NotImplementedError(msg.format(cls.__name__))
 
-    def __radd__(self, plot: ggplot) -> ggplot:
+    def __radd__(self, other: ggplot) -> ggplot:
         """
         Add layer representing stat object on the right
 
@@ -406,8 +406,8 @@ class stat(ABC, metaclass=Register):
         out :
             ggplot object with added layer
         """
-        plot += self.to_layer()  # Add layer
-        return plot
+        other += self.to_layer()  # Add layer
+        return other
 
     def to_layer(self) -> layer:
         """

plotnine/stats/stat_bindot.py

@@ -281,9 +281,7 @@ def densitybin(
     if all(pd.isna(x)):
         return pd.DataFrame()
 
-    if weight is None:
-        weight = np.ones(len(x))
-    weight = np.asarray(weight)
+    weight = np.ones(len(x)) if weight is None else np.array(list(weight))
     weight[np.isnan(weight)] = 0
 
     if rangee is None:

plotnine/stats/stat_density.py

@@ -102,9 +102,9 @@ class stat_density(stat):
                 # useful for stacked density plots
 
     'scaled'    # density estimate, scaled to maximum of 1
+    'n'         # Number of observations at a position
     ```
 
-        'n'         # Number of observations at a position
 
     """
     REQUIRED_AES = {"x"}
@@ -171,7 +171,7 @@ def compute_density(x, weight, range, **params):
     x = np.asarray(x, dtype=float)
     not_nan = ~np.isnan(x)
     x = x[not_nan]
-    bw = cast(str | float, params["bw"])
+    bw = cast("str | float", params["bw"])
     kernel = params["kernel"]
     bounds = params["bounds"]
     has_bounds = not (np.isneginf(bounds[0]) and np.isposinf(bounds[1]))

plotnine/stats/stat_qq_line.py

@@ -62,7 +62,7 @@ class stat_qq_line(stat):
     def setup_params(self, data):
         if len(self.params["line_p"]) != 2:
             raise PlotnineError(
-                "Cannot fit line quantiles. " "'line_p' must be of length 2"
+                "Cannot fit line quantiles. 'line_p' must be of length 2"
             )
         return self.params
 

plotnine/stats/stat_sina.py

@@ -57,6 +57,15 @@ class stat_sina(stat):
         - `area` - Scale by the largest density/bin among the different sinas
         - `count` - areas are scaled proportionally to the number of points
         - `width` - Only scale according to the maxwidth parameter.
+    style :
+        Type of sina plot to draw. The options are
+        ```python
+        'full'        # Regular (2 sided)
+        'left'        # Left-sided half
+        'right'       # Right-sided half
+        'left-right'  # Alternate (left first) half by the group
+        'right-left'  # Alternate (right first) half by the group
+        ```
 
     See Also
     --------
@@ -91,6 +100,7 @@ class stat_sina(stat):
         "bin_limit": 1,
         "random_state": None,
         "scale": "area",
+        "style": "full",
     }
     CREATES = {"scaled"}
 
@@ -101,7 +111,7 @@ class stat_sina(stat):
             and (data["x"] != data["x"].iloc[0]).any()
         ):
             raise TypeError(
-                "Continuous x aesthetic -- did you forget " "aes(group=...)?"
+                "Continuous x aesthetic -- did you forget aes(group=...)?"
             )
         return data
 
@@ -245,6 +255,29 @@ class stat_sina(stat):
 
     def finish_layer(self, data, params):
         # Rescale x in case positions have been adjusted
+        style = params["style"]
+        x_mean = data["x"].to_numpy()
         x_mod = (data["xmax"] - data["xmin"]) / data["width"]
         data["x"] = data["x"] + data["x_diff"] * x_mod
+        x = data["x"].to_numpy()
+        even = data["group"].to_numpy() % 2 == 0
+
+        def mirror_x(bool_idx):
+            """
+            Mirror x locations along the mean value
+            """
+            data.loc[bool_idx, "x"] = (
+                2 * x_mean[bool_idx] - data.loc[bool_idx, "x"]
+            )
+
+        match style:
+            case "left":
+                mirror_x(x_mean < x)
+            case "right":
+                mirror_x(x < x_mean)
+            case "left-right":
+                mirror_x(even & (x < x_mean) | ~even & (x_mean < x))
+            case "right-left":
+                mirror_x(even & (x_mean < x) | ~even & (x < x_mean))
+
         return data

plotnine/themes/elements/__init__.py

@@ -2,10 +2,13 @@ from .element_blank import element_blank
 from .element_line import element_line
 from .element_rect import element_rect
 from .element_text import element_text
+from .margin import margin, margin_auto
 
 __all__ = (
     "element_blank",
     "element_line",
     "element_rect",
     "element_text",
+    "margin",
+    "margin_auto",
 )

plotnine/themes/elements/element_text.py

@@ -8,10 +8,10 @@ from contextlib import suppress
 from typing import TYPE_CHECKING
 
 from .element_base import element_base
-from .margin import Margin
+from .margin import margin as Margin
 
 if TYPE_CHECKING:
-    from typing import Any, Literal, Optional, Sequence
+    from typing import Any, Literal, Sequence
 
     from plotnine import theme
 
@@ -56,7 +56,7 @@ class element_text(element_base):
         Margin around the text. The keys are
         `t`, `b`, `l`, `r` and `units`.
         The `tblr` keys are floats.
-        The `units` is one of `pt`, `lines` or `in`.
+        The `unit` is one of `pt`, `lines` or `in`.
         Not all text themeables support margin parameters and other
         than the `units`, only some of the other keys may apply.
     kwargs :
@@ -71,10 +71,10 @@ class element_text(element_base):
 
     def __init__(
         self,
-        family: Optional[str | list[str]] = None,
-        style: Optional[str | Sequence[str]] = None,
-        weight: Optional[int | str | Sequence[int | str]] = None,
-        color: Optional[
+        family: str | list[str] | None = None,
+        style: str | Sequence[str] | None = None,
+        weight: int | str | Sequence[int | str] | None = None,
+        color: (
             str
             | tuple[float, float, float]
             | tuple[float, float, float, float]
@@ -83,22 +83,25 @@ class element_text(element_base):
                 | tuple[float, float, float]
                 | tuple[float, float, float, float]
             ]
-        ] = None,
-        size: Optional[float | Sequence[float]] = None,
-        ha: Optional[Literal["center", "left", "right"] | float] = None,
-        va: Optional[
+            | None
+        ) = None,
+        size: float | Sequence[float] | None = None,
+        ha: Literal["center", "left", "right"] | float | None = None,
+        va: (
             Literal["center", "top", "bottom", "baseline", "center_baseline"]
             | float
-        ] = None,
-        ma: Optional[Literal["center", "left", "right"] | float] = None,
-        rotation: Optional[
+            | None
+        ) = None,
+        ma: Literal["center", "left", "right"] | float | None = None,
+        rotation: (
             Literal["vertical", "horizontal"]
             | float
             | Sequence[Literal["vertical", "horizontal"]]
             | Sequence[float]
-        ] = None,
-        linespacing: Optional[float] = None,
-        backgroundcolor: Optional[
+            | None
+        ) = None,
+        linespacing: float | None = None,
+        backgroundcolor: (
             str
             | tuple[float, float, float]
             | tuple[float, float, float, float]
@@ -107,10 +110,11 @@ class element_text(element_base):
                 | tuple[float, float, float]
                 | tuple[float, float, float, float]
             ]
-        ] = None,
-        margin: Optional[
-            dict[Literal["t", "b", "l", "r", "units"], Any]
-        ] = None,
+            | None
+        ) = None,
+        margin: (
+            Margin | dict[Literal["t", "b", "l", "r", "unit"], Any] | None
+        ) = None,
         rotation_mode: Literal["default", "anchor"] | None = None,
         **kwargs: Any,
     ):
@@ -139,8 +143,15 @@ class element_text(element_base):
 
         super().__init__()
         self.properties.update(**kwargs)
+
         if margin is not None:
-            self.properties["margin"] = Margin(self, **margin)
+            if isinstance(margin, dict):
+                if "units" in margin:
+                    # for backward compatibility
+                    margin["unit"] = margin.pop("units")  # pyright: ignore[reportArgumentType]
+                margin = Margin(**margin)
+
+            self.properties["margin"] = margin
 
         # Use the parameters that have been set
         names = (
@@ -153,6 +164,7 @@ class element_text(element_base):
             "size",
             "style",
             "va",
+            "ma",
             "weight",
             "rotation_mode",
         )
@@ -166,8 +178,7 @@ class element_text(element_base):
         Setup the theme_element before drawing
         """
         if m := self.properties.get("margin"):
-            m.theme = theme
-            m.themeable_name = themeable_name
+            m = m.setup(theme, themeable_name)
 
     def _translate_hjust(
         self, just: float

plotnine/themes/elements/margin.py

@@ -1,10 +1,12 @@
 """
-Theme elements used to decorate the graph.
+Margin
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from contextlib import suppress
+from copy import copy
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -12,80 +14,154 @@ if TYPE_CHECKING:
 
     from plotnine import theme
 
-    from .element_base import element_base
-
 
 @dataclass
-class Margin:
-    element: element_base
+class margin:
+    """
+    Margin
+    """
+
     t: float = 0
+    """
+    Top margin
+    """
+
+    r: float = 0
+    """
+    Right margin
+    """
+
     b: float = 0
+    """
+    Bottom margin
+    """
+
     l: float = 0
-    r: float = 0
-    units: Literal["pt", "in", "lines", "fig"] = "pt"
-
-    def __post_init__(self):
-        self.theme: theme
-        self.themeable_name: str
-
-        if self.units in ("pts", "points", "px", "pixels"):
-            self.units = "pt"
-        elif self.units in ("in", "inch", "inches"):
-            self.units = "in"
-        elif self.units in ("line", "lines"):
-            self.units = "lines"
-
-    def __eq__(self, other: object) -> bool:
-        def _size(m: Margin):
-            return m.element.properties.get("size")
-
-        return other is self or (
-            isinstance(other, type(self))
-            and other.t == self.t
-            and other.b == self.b
-            and other.l == self.l
-            and other.r == self.r
-            and other.units == self.units
-            and _size(other) == _size(self)
-        )
-
-    def get_as(
-        self,
-        loc: Literal["t", "b", "l", "r"],
-        units: Literal["pt", "in", "lines", "fig"] = "pt",
-    ) -> float:
+    """
+    Left Margin
+    """
+
+    unit: Literal["pt", "in", "lines", "fig"] = "pt"
+    """
+    The units (coordinate space) of the values
+    """
+
+    # These are set by the themeable when it is applied
+    fontsize: float = field(init=False, default=0)
+    """
+    Font size of text that this margin applies to
+    """
+
+    figure_size: tuple[float, float] = field(init=False, default=(0, 0))
+    """
+    Size of the figure in inches
+    """
+
+    def setup(self, theme: theme, themeable_name: str):
+        """
+        Setup the margin to be used in the layout
+
+        For the margin's values to be useful, we need to be able to
+        convert them to different units as is required. Here we get
+        all the parameters that we shall need to do the conversions.
+        """
+        self.themeable_name = themeable_name
+        self.fontsize = theme.getp((themeable_name, "size"), 11)
+        self.figure_size = theme.getp("figure_size")
+
+    @property
+    def pt(self) -> margin:
+        """
+        Return margin in points
+
+        These are the units of the display coordinate system
+        """
+        return self.to("pt")
+
+    @property
+    def inch(self) -> margin:
+        """
+        Return margin in inches
+
+        These are the units of the figure-inches coordinate system
+        """
+        return self.to("in")
+
+    @property
+    def lines(self) -> margin:
+        """
+        Return margin in lines units
+        """
+        return self.to("lines")
+
+    @property
+    def fig(self) -> margin:
+        """
+        Return margin in figure units
+
+        These are the units of the figure coordinate system
+        """
+        return self.to("fig")
+
+    def to(self, unit: Literal["pt", "in", "lines", "fig"]) -> margin:
         """
-        Return key in given units
+        Return margin in request unit
         """
+        m = copy(self)
+        if self.unit == unit:
+            return m
+
+        conversion = f"{self.unit}-{unit}"
+        W, H = self.figure_size
+
+        with suppress(ZeroDivisionError):
+            m.t = self._convert(conversion, H, self.t)
+        with suppress(ZeroDivisionError):
+            m.r = self._convert(conversion, W, self.r)
+        with suppress(ZeroDivisionError):
+            m.b = self._convert(conversion, H, self.b)
+        with suppress(ZeroDivisionError):
+            m.l = self._convert(conversion, W, self.l)
+
+        m.unit = unit
+        return m
+
+    def _convert(self, conversion: str, D: float, value: float) -> float:
         dpi = 72
-        size: float = self.theme.getp((self.themeable_name, "size"), 11)
-        from_units = self.units
-        to_units = units
-        W: float
-        H: float
-        W, H = self.theme.getp("figure_size")  # inches
-        L = (W * dpi) if loc in "tb" else (H * dpi)  # pts
+        L = D * dpi  # pts
 
         functions: dict[str, Callable[[float], float]] = {
             "fig-in": lambda x: x * L / dpi,
-            "fig-lines": lambda x: x * L / size,
+            "fig-lines": lambda x: x * L / self.fontsize,
             "fig-pt": lambda x: x * L,
             "in-fig": lambda x: x * dpi / L,
-            "in-lines": lambda x: x * dpi / size,
+            "in-lines": lambda x: x * dpi / self.fontsize,
             "in-pt": lambda x: x * dpi,
-            "lines-fig": lambda x: x * size / L,
-            "lines-in": lambda x: x * size / dpi,
-            "lines-pt": lambda x: x * size,
+            "lines-fig": lambda x: x * self.fontsize / L,
+            "lines-in": lambda x: x * self.fontsize / dpi,
+            "lines-pt": lambda x: x * self.fontsize,
             "pt-fig": lambda x: x / L,
             "pt-in": lambda x: x / dpi,
-            "pt-lines": lambda x: x / size,
+            "pt-lines": lambda x: x / self.fontsize,
         }
 
-        value: float = getattr(self, loc)
-        if from_units != to_units:
-            conversion = f"{self.units}-{units}"
-            try:
-                value = functions[conversion](value)
-            except ZeroDivisionError:
-                value = 0
-        return value
+        return functions[conversion](value)
+
+
+def margin_auto(
+    t: float = 0.0,
+    r: float | None = None,
+    b: float | None = None,
+    l: float | None = None,
+    unit: Literal["pt", "in", "lines", "fig"] = "pt",
+) -> margin:
+    """
+    Create margin with minimal arguments
+    """
+    if r is None:
+        r = t
+    if b is None:
+        b = t
+    if l is None:
+        l = r
+    return margin(t, r, b, l, unit)

plotnine/themes/targets.py

@@ -21,7 +21,7 @@ class ThemeTargets:
     """
     Artists that will be themed
 
-    This includes only artist that cannot be accessed easily from
+    This includes only artist that cannot be easily accessed from
     the figure or the axes.
     """
 
@@ -37,7 +37,9 @@ class ThemeTargets:
     panel_border: list[Rectangle] = field(default_factory=list)
     plot_caption: Optional[Text] = None
     plot_subtitle: Optional[Text] = None
+    plot_tag: Optional[Text] = None
     plot_title: Optional[Text] = None
+    plot_background: Optional[Rectangle] = None
     strip_background_x: list[StripTextPatch] = field(default_factory=list)
     strip_background_y: list[StripTextPatch] = field(default_factory=list)
     strip_text_x: list[StripText] = field(default_factory=list)