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

plotnine/geoms/geom_ribbon.py

@@ -94,7 +94,7 @@ class geom_ribbon(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         _x = "y" if isinstance(coord, coord_flip) else "x"
         data = coord.transform(data, panel_params, munch=True)
@@ -107,7 +107,7 @@ class geom_ribbon(geom):
 
         for _, udata in data.groupby(units, dropna=False):
             udata.reset_index(inplace=True, drop=True)
-            geom_ribbon.draw_unit(udata, panel_params, coord, ax, **params)
+            geom_ribbon.draw_unit(udata, panel_params, coord, ax, params)
 
     @staticmethod
     def draw_unit(
@@ -115,7 +115,7 @@ class geom_ribbon(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         linewidth = data["size"].iloc[0] * SIZE_FACTOR
         fill = to_rgba(data["fill"], data["alpha"])
@@ -159,7 +159,7 @@ class geom_ribbon(geom):
 
         # Alpha does not affect the outlines
         data["alpha"] = 1
-        geom_ribbon._draw_outline(data, panel_params, coord, ax, **params)
+        geom_ribbon._draw_outline(data, panel_params, coord, ax, params)
 
     @staticmethod
     def _draw_outline(
@@ -167,7 +167,7 @@ class geom_ribbon(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         outline_type = params["outline_type"]
 
@@ -185,7 +185,7 @@ class geom_ribbon(geom):
                 panel_params,
                 coord,
                 ax,
-                **params,
+                params,
             )
 
         if outline_type in ("upper", "both"):
@@ -194,5 +194,5 @@ class geom_ribbon(geom):
                 panel_params,
                 coord,
                 ax,
-                **params,
+                params,
             )

plotnine/geoms/geom_rug.py

@@ -60,7 +60,7 @@ class geom_rug(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         from matplotlib.collections import LineCollection
 

plotnine/geoms/geom_segment.py

@@ -64,7 +64,7 @@ class geom_segment(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         from matplotlib.collections import LineCollection
 
@@ -100,5 +100,5 @@ class geom_segment(geom):
                 adata[param] = np.hstack([data[param], data[param]])
 
             params["arrow"].draw(
-                adata, panel_params, coord, ax, constant=False, **params
+                adata, panel_params, coord, ax, params, constant=False
             )

plotnine/geoms/geom_smooth.py

@@ -78,7 +78,7 @@ class geom_smooth(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         has_ribbon = "ymin" in data and "ymax" in data
         if has_ribbon:
@@ -86,10 +86,10 @@ class geom_smooth(geom):
             data2["color"] = "none"
             params2 = params.copy()
             params2["outline_type"] = "full"
-            geom_ribbon.draw_group(data2, panel_params, coord, ax, **params2)
+            geom_ribbon.draw_group(data2, panel_params, coord, ax, params2)
 
         data["alpha"] = 1
-        geom_line.draw_group(data, panel_params, coord, ax, **params)
+        geom_line.draw_group(data, panel_params, coord, ax, params)
 
     @staticmethod
     def draw_legend(

plotnine/geoms/geom_step.py

@@ -54,7 +54,7 @@ class geom_step(geom_path):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         direction = params["direction"]
         n = len(data)
@@ -84,4 +84,4 @@ class geom_step(geom_path):
 
         path_data = pd.DataFrame({"x": new_x, "y": new_y})
         copy_missing_columns(path_data, data)
-        geom_path.draw_group(path_data, panel_params, coord, ax, **params)
+        geom_path.draw_group(path_data, panel_params, coord, ax, params)

plotnine/geoms/geom_text.py

@@ -214,9 +214,8 @@ class geom_text(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
-        super().draw_panel(data, panel_params, coord, ax, **params)
+        super().draw_panel(data, panel_params, coord, ax)
 
     @staticmethod
     def draw_group(
@@ -224,7 +223,7 @@ class geom_text(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         data = coord.transform(data, panel_params)
         zorder = params["zorder"]

plotnine/geoms/geom_violin.py

@@ -113,8 +113,8 @@ class geom_violin(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
+        params = self.params.copy()
         quantiles = params.pop("draw_quantiles")
         style = params.pop("style")
         zorder = params.pop("zorder")
@@ -125,6 +125,7 @@ class geom_violin(geom):
             # in the range [zorder, zorder + 1) to stay within the layer.
             group = cast("int", group)
             group_zorder = zorder + 0.9 / group
+            params["zorder"] = group_zorder
 
             # Find the points for the line to go all the way around
             df["xminv"] = df["x"] - df["violinwidth"] * (df["x"] - df["xmin"])
@@ -167,8 +168,7 @@ class geom_violin(geom):
                 panel_params,
                 coord,
                 ax,
-                zorder=group_zorder,
-                **params,
+                params,
             )
 
             if quantiles is not None:
@@ -190,8 +190,7 @@ class geom_violin(geom):
                     panel_params,
                     coord,
                     ax,
-                    zorder=group_zorder,
-                    **params,
+                    params,
                 )
 
 

plotnine/geoms/geom_vline.py

@@ -80,7 +80,6 @@ class geom_vline(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
         """
         Plot all groups
@@ -94,7 +93,9 @@ class geom_vline(geom):
 
         for _, gdata in data.groupby("group"):
             gdata.reset_index(inplace=True)
-            geom_segment.draw_group(gdata, panel_params, coord, ax, **params)
+            geom_segment.draw_group(
+                gdata, panel_params, coord, ax, self.params
+            )
 
     @staticmethod
     def draw_legend(

plotnine/guides/guides.py

@@ -369,7 +369,7 @@ class guides:
         # place the guides according to the guide.order
         default = max(g.order for g in gdefs) + 1
         orders = [default if g.order == 0 else g.order for g in gdefs]
-        idx: list[int] = list(np.argsort(orders))
+        idx = cast("Sequence[int]", np.argsort(orders))
         gdefs = [gdefs[i] for i in idx]
 
         # Draw each guide into a box

plotnine/layer.py

@@ -163,6 +163,7 @@ class layer:
         self._make_layer_data(plot.data)
         self._make_layer_mapping(plot.mapping)
         self._make_layer_environments(plot.environment)
+        self._share_layer_params()
 
     def _make_layer_data(self, plot_data: DataLike | None):
         """
@@ -250,6 +251,13 @@ class layer:
         self.geom.environment = plot_environment
         self.stat.environment = plot_environment
 
+    def _share_layer_params(self):
+        """
+        Pass necessary layer parameters to the geom
+        """
+        self.geom.params["zorder"] = self.zorder
+        self.geom.params["raster"] = self.raster
+
     def compute_aesthetics(self, plot: ggplot):
         """
         Return a dataframe where the columns match the aesthetic mappings
@@ -278,10 +286,10 @@ class layer:
         if not len(data):
             return
 
-        params = self.stat.setup_params(data)
+        self.stat.setup_params(data)
         data = self.stat.use_defaults(data)
         data = self.stat.setup_data(data)
-        data = self.stat.compute_layer(data, params, layout)
+        data = self.stat.compute_layer(data, layout)
         self.data = data
 
     def map_statistic(self, plot: ggplot):
@@ -320,6 +328,8 @@ class layer:
         if len(data) == 0:
             return
 
+        self.geom.params.update(self.stat.params)
+        self.geom.setup_params(data)
         data = self.geom.setup_data(data)
 
         check_required_aesthetics(
@@ -357,14 +367,10 @@ class layer:
         coord : coord
             Type of coordinate axes
         """
-        params = copy(self.geom.params)
-        params.update(self.stat.params)
-        params["zorder"] = self.zorder
-        params["raster"] = self.raster
         self.data = self.geom.handle_na(self.data)
         # At this point each layer must have the data
         # that is created by the plot build process
-        self.geom.draw_layer(self.data, layout, coord, **params)
+        self.geom.draw_layer(self.data, layout, coord)
 
     def use_defaults(
         self,
@@ -399,7 +405,7 @@ class layer:
         """
         Prepare/modify data for plotting
         """
-        self.stat.finish_layer(self.data, self.stat.params)
+        self.stat.finish_layer(self.data)
 
 
 class Layers(List[layer]):
@@ -450,7 +456,9 @@ class Layers(List[layer]):
         return [l.data for l in self]
 
     def setup(self, plot: ggplot):
-        for l in self:
+        # If zorder is 0, it is left to MPL
+        for i, l in enumerate(self, start=1):
+            l.zorder = i
             l.setup(plot)
 
     def setup_data(self):
@@ -458,9 +466,7 @@ class Layers(List[layer]):
             l.setup_data()
 
     def draw(self, layout: Layout, coord: coord):
-        # If zorder is 0, it is left to MPL
-        for i, l in enumerate(self, start=1):
-            l.zorder = i
+        for l in self:
             l.draw(layout, coord)
 
     def compute_aesthetics(self, plot: ggplot):

plotnine/mapping/_eval_environment.py

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

plotnine/scales/scale_color.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import KW_ONLY, InitVar, dataclass
+from dataclasses import KW_ONLY, InitVar, dataclass, field
 from typing import Literal, Sequence
 from warnings import warn
 
@@ -50,34 +50,66 @@ class scale_color_hue(_scale_color_discrete):
     Qualitative color scale with evenly spaced hues
     """
 
-    h: InitVar[float] = 0.01
+    h: InitVar[float | tuple[float, float]] = 15
     """
-    Hue. Must be in the range [0, 1]
+    Hue. If a float, it is the first hue value, in the range `[0, 360]`.
+    The range of the palette will be `[first, first + 360)`.
+
+    If a tuple, it is the range `[first, last)` of the hues.
     """
 
-    l: InitVar[float] = 0.6
+    c: InitVar[float] = 100
     """
-    Lightness. Must be in the range [0, 1]
+    Chroma. Must be in the range `[0, 100]`
     """
 
-    s: InitVar[float] = 0.65
+    l: InitVar[float] = 65
     """
-    Saturation. Must be in the range [0, 1]
+    Lightness. Must be in the range [0, 100]
     """
 
-    color_space: InitVar[Literal["hls", "hsluv"]] = "hls"
+    direction: InitVar[Literal[1, -1]] = 1
     """
-    Color space to use. Should be one of
-    [hls](https://en.wikipedia.org/wiki/HSL_and_HSV)
-    or [hsluv](https://www.hsluv.org/).
-    https://www.hsluv.org/
+    The order of colours in the scale. If -1 the order
+    of colours is reversed. The default is 1.
     """
 
-    def __post_init__(self, h, l, s, color_space):
+    _: KW_ONLY
+
+    s: None = field(default=None, repr=False)
+    """
+    Not being use and will be removed in a future version
+    """
+    color_space: None = field(default=None, repr=False)
+    """
+    Not being use and will be removed in a future version
+    """
+
+    def __post_init__(self, h, c, l, direction):
         from mizani.palettes import hue_pal
 
+        if (s := self.s) is not None:
+            warn(
+                f"You used {s=} for the saturation which has been ignored. "
+                f"{self.__class__.__name__} now works in HCL colorspace. "
+                f"Using `s` in future versions will throw an exception.",
+                FutureWarning,
+            )
+            del self.s
+
+        if (color_space := self.color_space) is not None:
+            warn(
+                f"You used {color_space=} to select a color_space and it "
+                f"has been ignored. {self.__class__.__name__} now only works "
+                f"in HCL colorspace. Using `color_space` in future versions "
+                "will throw an exception.",
+                FutureWarning,
+            )
+            del self.color_space
+
         super().__post_init__()
-        self.palette = hue_pal(h, l, s, color_space=color_space)
+        self.palette = hue_pal(h, c, l, direction)
+        self.palette.h
 
 
 @dataclass

plotnine/scales/scale_continuous.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from contextlib import suppress
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Sequence
+from typing import TYPE_CHECKING, Sequence, cast
 from warnings import warn
 
 import numpy as np
@@ -387,15 +387,16 @@ class scale_continuous(
             limits = self.final_limits
 
         x = self.oob(self.rescaler(x, _from=limits))
+        na_value = cast("float", self.na_value)
 
         uniq = np.unique(x)
         pal = np.asarray(self.palette(uniq))
         scaled = pal[match(x, uniq)]
         if scaled.dtype.kind == "U":
-            scaled = [self.na_value if x == "nan" else x for x in scaled]
+            scaled = [na_value if x == "nan" else x for x in scaled]
         else:
-            scaled[pd.isna(scaled)] = self.na_value
-        return scaled
+            scaled[pd.isna(scaled)] = na_value
+        return scaled  # pyright: ignore[reportReturnType]
 
     def get_breaks(
         self, limits: Optional[tuple[float, float]] = None

plotnine/scales/scale_datetime.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import KW_ONLY, InitVar, dataclass
 from typing import TYPE_CHECKING
+from warnings import warn
 
 from ._runtime_typing import TransUser  # noqa: TCH001
 from .scale_continuous import scale_continuous
@@ -20,24 +21,21 @@ class scale_datetime(scale_continuous):
     """
     A string giving the distance between major breaks.
     For example `'2 weeks'`, `'5 years'`. If specified,
-    `date_breaks` takes precedence over
-    `breaks`.
+    `date_breaks` takes precedence over `breaks`.
     """
 
     date_labels: InitVar[str | None] = None
     """
     Format string for the labels.
     See [strftime](:ref:`strftime-strptime-behavior`).
-    If specified, `date_labels` takes precedence over
-    `labels`.
+    If specified, `date_labels` takes precedence over `labels`.
     """
 
     date_minor_breaks: InitVar[str | None] = None
     """
     A string giving the distance between minor breaks.
     For example `'2 weeks'`, `'5 years'`. If specified,
-    `date_minor_breaks` takes precedence over
-    `minor_breaks`.
+    `date_minor_breaks` takes precedence over `minor_breaks`.
     """
 
     _: KW_ONLY
@@ -80,22 +78,38 @@ class scale_datetime(scale_continuous):
         date_labels: str | None,
         date_minor_breaks: str | None,
     ):
-        from mizani.breaks import breaks_date as breaks_func
-        from mizani.labels import label_date as labels_func
+        from mizani.breaks import breaks_date_width
+        from mizani.labels import label_date
 
         if date_breaks is not None:
-            self.breaks = breaks_func(date_breaks)  # pyright: ignore
+            self.breaks = breaks_date_width(date_breaks)  # pyright: ignore[reportAttributeAccessIssue]
         elif isinstance(self.breaks, str):
-            self.breaks = breaks_func(width=self.breaks)  # pyright: ignore
+            warn(
+                "Passing a string to `breaks` will not work in "
+                f"future versions. Use `date_breaks={self.breaks!r}`",
+                FutureWarning,
+            )
+            self.breaks = breaks_date_width(width=self.breaks)  # pyright: ignore[reportAttributeAccessIssue]
 
         if date_labels is not None:
-            self.labels = labels_func(date_labels)  # pyright: ignore
+            self.labels = label_date(fmt=date_labels)  # pyright: ignore[reportAttributeAccessIssue]
         elif isinstance(self.labels, str):
-            self.labels = labels_func(width=self.labels)  # pyright: ignore
+            warn(
+                "Passing a string to `labels` will not work in "
+                f"future versions. Use `date_labels={self.labels!r}`",
+                FutureWarning,
+            )
+            self.labels = label_date(fmt=self.labels)  # pyright: ignore[reportAttributeAccessIssue]
 
         if date_minor_breaks is not None:
-            self.minor_breaks = breaks_func(date_minor_breaks)  # pyright: ignore
+            self.minor_breaks = breaks_date_width(date_minor_breaks)  # pyright: ignore[reportAttributeAccessIssue]
         elif isinstance(self.minor_breaks, str):
-            self.minor_breaks = breaks_func(width=self.minor_breaks)  # pyright: ignore
+            warn(
+                "Passing a string to `minor_breaks` will not work in "
+                "future versions. "
+                f"Use `date_minor_breaks={self.minor_breaks!r}`",
+                FutureWarning,
+            )
+            self.minor_breaks = breaks_date_width(width=self.minor_breaks)  # pyright: ignore[reportAttributeAccessIssue]
 
         scale_continuous.__post_init__(self)

plotnine/scales/scale_discrete.py

@@ -156,7 +156,7 @@ class scale_discrete(
             range = self.dimension(limits=limits)
 
         breaks_d = self.get_breaks(limits)
-        breaks = self.map(pd.Categorical(breaks_d))
+        breaks = self.map(pd.Categorical(breaks_d))  # pyright: ignore[reportArgumentType]
         minor_breaks = []
         labels = self.get_labels(breaks_d)
 
@@ -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]
+                pal_match = [pal[i] if i >= 0 else None for i in idx]  # pyright: ignore[reportCallIssue,reportArgumentType]
             except IndexError:
                 # Deal with missing data
                 # - Insert NaN where there is no match

plotnine/scales/scale_xy.py

@@ -213,7 +213,7 @@ class scale_x_discrete(scale_position_discrete):
     Discrete x position
     """
 
-    _aesthetics = ["x", "xmin", "xmax", "xend"]
+    _aesthetics = ["x", "xmin", "xmax", "xend", "xintercept"]
 
 
 @dataclass(kw_only=True)
@@ -222,7 +222,7 @@ class scale_y_discrete(scale_position_discrete):
     Discrete y position
     """
 
-    _aesthetics = ["y", "ymin", "ymax", "yend"]
+    _aesthetics = ["y", "ymin", "ymax", "yend", "yintercept"]
 
 
 # Not part of the user API