plotnine 0.15.0.dev1__py3-none-any.whl → 0.15.0.dev3__py3-none-any.whl

plotnine/geoms/geom_bar.py

@@ -20,6 +20,11 @@ class geom_bar(geom_rect):
     Parameters
     ----------
     {common_parameters}
+    just : float, default=0.5
+        How to align the column with respect to the axis breaks. The default
+        `0.5` aligns the center of the column with the break. `0` aligns the
+        left of the of the column with the break and `1` aligns the right of
+        the column with the break.
     width : float, default=None
         Bar width. If `None`{.py}, the width is set to
         `90%` of the resolution of the data.
@@ -35,6 +40,7 @@ class geom_bar(geom_rect):
         "stat": "count",
         "position": "stack",
         "na_rm": False,
+        "just": 0.5,
         "width": None,
     }
 
@@ -45,6 +51,8 @@ class geom_bar(geom_rect):
             else:
                 data["width"] = resolution(data["x"], False) * 0.9
 
+        just = self.params.get("just", 0.5)
+
         bool_idx = data["y"] < 0
 
         data["ymin"] = 0.0
@@ -53,7 +61,7 @@ class geom_bar(geom_rect):
         data["ymax"] = data["y"]
         data.loc[bool_idx, "ymax"] = 0.0
 
-        data["xmin"] = data["x"] - data["width"] / 2
-        data["xmax"] = data["x"] + data["width"] / 2
+        data["xmin"] = data["x"] - data["width"] * just
+        data["xmax"] = data["x"] + data["width"] * (1 - just)
         del data["width"]
         return data

plotnine/geoms/geom_col.py

@@ -17,6 +17,11 @@ class geom_col(geom_bar):
     Parameters
     ----------
     {common_parameters}
+    just : float, default=0.5
+        How to align the column with respect to the axis breaks. The default
+        `0.5` aligns the center of the column with the break. `0` aligns the
+        left of the of the column with the break and `1` aligns the right of
+        the column with the break.
     width : float, default=None
         Bar width. If `None`{.py}, the width is set to
         `90%` of the resolution of the data.
@@ -32,5 +37,6 @@ class geom_col(geom_bar):
         "stat": "identity",
         "position": "stack",
         "na_rm": False,
+        "just": 0.5,
         "width": None,
     }

plotnine/geoms/geom_violin.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
 import pandas as pd
@@ -11,7 +11,7 @@ from .geom import geom
 from .geom_path import geom_path
 from .geom_polygon import geom_polygon
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from typing import Any
 
     from matplotlib.axes import Axes
@@ -115,10 +115,17 @@ class geom_violin(geom):
         ax: Axes,
         **params: Any,
     ):
-        quantiles = params["draw_quantiles"]
-        style = params["style"]
+        quantiles = params.pop("draw_quantiles")
+        style = params.pop("style")
+        zorder = params.pop("zorder")
+
+        for i, (group, df) in enumerate(data.groupby("group")):
+            # Place the violins with the smalleer group number on top
+            # of those with larger numbers. The group_zorder values should be
+            # in the range [zorder, zorder + 1) to stay within the layer.
+            group = cast("int", group)
+            group_zorder = zorder + 0.9 / group
 
-        for i, (_, df) in enumerate(data.groupby("group")):
             # Find the points for the line to go all the way around
             df["xminv"] = df["x"] - df["violinwidth"] * (df["x"] - df["xmin"])
             df["xmaxv"] = df["x"] + df["violinwidth"] * (df["xmax"] - df["x"])
@@ -156,7 +163,12 @@ class geom_violin(geom):
 
             # plot violin polygon
             geom_polygon.draw_group(
-                polygon_df, panel_params, coord, ax, **params
+                polygon_df,
+                panel_params,
+                coord,
+                ax,
+                zorder=group_zorder,
+                **params,
             )
 
             if quantiles is not None:
@@ -174,7 +186,12 @@ class geom_violin(geom):
 
                 # plot quantile segments
                 geom_path.draw_group(
-                    segment_df, panel_params, coord, ax, **params
+                    segment_df,
+                    panel_params,
+                    coord,
+                    ax,
+                    zorder=group_zorder,
+                    **params,
                 )
 
 

plotnine/guides/guide.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
     from plotnine import aes, guides
-    from plotnine.layer import Layers
+    from plotnine.layer import Layers, layer
     from plotnine.scales.scale import scale
     from plotnine.typing import (
         LegendPosition,
@@ -79,7 +79,7 @@ class guide(ABC, metaclass=Register):
         self.elements = cast("GuideElements", None)
         self.guides_elements: GuidesElements
 
-    def legend_aesthetics(self, layer):
+    def legend_aesthetics(self, layer: layer):
         """
         Return the aesthetics that contribute to the legend
 

plotnine/guides/guide_legend.py

@@ -171,21 +171,20 @@ class guide_legend(guide):
             # Modify aesthetics
 
             # When doing after_scale evaluations, we only consider those
-            # for the aesthetics of this legend. The reduces the spurious
-            # warnings where an evaluation of another aesthetic failed yet
-            # it is not needed.
+            # for the aesthetics that are valid for this layer/geom.
             aes_modifiers = {
-                ae: expr
-                for ae, expr in l.mapping._scaled.items()
-                if ae in matched_set
+                ae: l.mapping._scaled[ae]
+                for ae in l.geom.aesthetics() & l.mapping._scaled.keys()
             }
 
             try:
                 data = l.use_defaults(data, aes_modifiers)
             except PlotnineError:
                 warn(
-                    "Failed to apply `after_scale` modifications "
-                    "to the legend.",
+                    "Failed to apply `after_scale` modifications to the "
+                    "legend. This probably should not happen. Help us "
+                    "discover why, please open and issue at "
+                    "https://github.com/has2k1/plotnine/issues",
                     PlotnineWarning,
                 )
                 data = l.use_defaults(data, {})

plotnine/iapi.py

@@ -22,8 +22,10 @@ if TYPE_CHECKING:
     from plotnine.typing import (
         CoordRange,
         FloatArrayLike,
+        HorizontalJustification,
         ScaledAestheticsName,
         StripPosition,
+        VerticalJustification,
     )
 
     from ._mpl.offsetbox import FlexibleAnchoredOffsetbox
@@ -231,8 +233,8 @@ class strip_draw_info:
 
     x: float
     y: float
-    ha: str
-    va: str
+    ha: HorizontalJustification | float
+    va: VerticalJustification | float
     box_width: float
     box_height: float
     strip_text_margin: float

plotnine/mapping/_eval_environment.py

@@ -0,0 +1,85 @@
+"""
+These are functions that can be called by the user inside the aes()
+mapping. This is meant to make it easy to transform column-variables
+as easily as is possible in ggplot2.
+
+We only implement the most common functions.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+
+if TYPE_CHECKING:
+    from typing import Any, Sequence
+
+__all__ = (
+    "factor",
+    "reorder",
+)
+
+
+def factor(
+    values: Sequence[Any],
+    categories: Sequence[Any] | None = None,
+    ordered: bool | None = None,
+) -> pd.Categorical:
+    """
+    Turn x in to a categorical (factor) variable
+
+    It is just an alias to `pandas.Categorical`
+
+    Parameters
+    ----------
+    values :
+        The values of the categorical. If categories are given, values not in
+        categories will be replaced with NaN.
+    categories :
+        The unique categories for this categorical. If not given, the
+        categories are assumed to be the unique values of `values`
+        (sorted, if possible, otherwise in the order in which they appear).
+    ordered :
+        Whether or not this categorical is treated as a ordered categorical.
+        If True, the resulting categorical will be ordered.
+        An ordered categorical respects, when sorted, the order of its
+        `categories` attribute (which in turn is the `categories` argument, if
+        provided).
+    """
+    return pd.Categorical(values, categories=categories, ordered=None)
+
+
+def reorder(x, y, fun=np.median, ascending=True):
+    """
+    Reorder categorical by sorting along another variable
+
+    It is the order of the categories that changes. Values in x
+    are grouped by categories and summarised to determine the
+    new order.
+
+    Credit: Copied from plydata
+
+    Parameters
+    ----------
+    x : list-like
+        Values that will make up the categorical.
+    y : list-like
+        Values by which `c` will be ordered.
+    fun : callable
+        Summarising function to `x` for each category in `c`.
+        Default is the *median*.
+    ascending : bool
+        If `True`, the `c` is ordered in ascending order of `x`.
+    """
+    if len(x) != len(y):
+        raise ValueError(f"Lengths are not equal. {len(x)=}, {len(x)=}")
+    summary = (
+        pd.Series(y)
+        .groupby(x, observed=True)
+        .apply(fun)
+        .sort_values(ascending=ascending)
+    )
+    cats = summary.index.to_list()
+    return pd.Categorical(x, categories=cats)

plotnine/mapping/aes.py

@@ -1,19 +1,19 @@
 from __future__ import annotations
 
 import re
-import typing
 from collections.abc import Iterable, Sequence
 from contextlib import suppress
 from copy import deepcopy
 from dataclasses import fields
-from typing import Any, Dict
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, Dict
 
 import pandas as pd
 
 from ..iapi import labels_view
 from .evaluation import after_stat, stage
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from typing import Protocol, TypeVar
 
     class ColorOrColour(Protocol):
@@ -171,27 +171,11 @@ class aes(Dict[str, Any]):
       ggplot(df, aes(x="df.index", y="np.sin(gam ma)"))
       ```
 
-    `aes` has 2 internal methods you can use to transform variables being
-    mapped.
+    `aes` has 2 internal functions that you can use in your expressions
+    when transforming the variables.
 
-      1. `factor` - This function turns the variable into a factor.
-         It is just an alias to `pandas.Categorical`:
-
-         ```python
-         ggplot(mtcars, aes(x="factor(cyl)")) + geom_bar()
-         ```
-
-      2. `reorder` - This function changes the order of first variable
-         based on values of the second variable:
-
-         ```python
-         df = pd.DataFrame({
-             "x": ["b", "d", "c", "a"],
-             "y": [1, 2, 3, 4]
-         })
-
-         ggplot(df, aes("reorder(x, y)", "y")) + geom_col()
-         ```
+      1. [](:func:`~plotnine.mapping._eval_environment.factor`)
+      1. [](:func:`~plotnine.mapping._eval_environment.reorder`)
 
     **The group aesthetic**
 
@@ -237,7 +221,7 @@ class aes(Dict[str, Any]):
                 kwargs[name] = after_stat(_after_stat)
         return kwargs
 
-    @property
+    @cached_property
     def _starting(self) -> dict[str, Any]:
         """
         Return the subset of aesthetics mapped from the layer data
@@ -254,7 +238,7 @@ class aes(Dict[str, Any]):
 
         return d
 
-    @property
+    @cached_property
     def _calculated(self) -> dict[str, Any]:
         """
         Return only the aesthetics mapped to calculated statistics
@@ -269,7 +253,7 @@ class aes(Dict[str, Any]):
 
         return d
 
-    @property
+    @cached_property
     def _scaled(self) -> dict[str, Any]:
         """
         Return only the aesthetics mapped to after scaling

plotnine/mapping/evaluation.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 import numbers
-import typing
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
 import pandas.api.types as pdtypes
 
 from ..exceptions import PlotnineError
+from ._eval_environment import factor, reorder
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from typing import Any
 
     from . import aes
@@ -18,6 +19,9 @@ if typing.TYPE_CHECKING:
 
 __all__ = ("after_stat", "after_scale", "stage")
 
+
+EVAL_ENVIRONMENT = {"factor": factor, "reorder": reorder}
+
 _TPL_EVAL_FAIL = """\
 Could not evaluate the '{}' mapping: '{}' \
 (original error: {})"""
@@ -108,68 +112,6 @@ def after_scale(x):
     return stage(after_scale=x)
 
 
-def reorder(x, y, fun=np.median, ascending=True):
-    """
-    Reorder categorical by sorting along another variable
-
-    It is the order of the categories that changes. Values in x
-    are grouped by categories and summarised to determine the
-    new order.
-
-    Credit: Copied from plydata
-
-    Parameters
-    ----------
-    x : list-like
-        Values that will make up the categorical.
-    y : list-like
-        Values by which `c` will be ordered.
-    fun : callable
-        Summarising function to `x` for each category in `c`.
-        Default is the *median*.
-    ascending : bool
-        If `True`, the `c` is ordered in ascending order of `x`.
-
-    Examples
-    --------
-    >>> c = list('abbccc')
-    >>> x = [11, 2, 2, 3, 33, 3]
-    >>> cat_reorder(c, x)
-    [a, b, b, c, c, c]
-    Categories (3, object): [b, c, a]
-    >>> cat_reorder(c, x, fun=max)
-    [a, b, b, c, c, c]
-    Categories (3, object): [b, a, c]
-    >>> cat_reorder(c, x, fun=max, ascending=False)
-    [a, b, b, c, c, c]
-    Categories (3, object): [c, a, b]
-    >>> c_ordered = pd.Categorical(c, ordered=True)
-    >>> cat_reorder(c_ordered, x)
-    [a, b, b, c, c, c]
-    Categories (3, object): [b < c < a]
-    >>> cat_reorder(c + ['d'], x)
-    Traceback (most recent call last):
-        ...
-    ValueError: Lengths are not equal. len(c) is 7 and len(x) is 6.
-    """
-    if len(x) != len(y):
-        raise ValueError(f"Lengths are not equal. {len(x)=}, {len(x)=}")
-    summary = (
-        pd.Series(y)
-        .groupby(x, observed=True)
-        .apply(fun)
-        .sort_values(ascending=ascending)
-    )
-    cats = summary.index.to_list()
-    return pd.Categorical(x, categories=cats)
-
-
-# These are function that can be called by the user inside the aes()
-# mapping. This is meant to make the variable transformations as easy
-# as they are in ggplot2
-AES_INNER_NAMESPACE = {"factor": pd.Categorical, "reorder": reorder}
-
-
 def evaluate(
     aesthetics: aes | dict[str, Any], data: pd.DataFrame, env: Environment
 ) -> pd.DataFrame:
@@ -207,7 +149,7 @@ def evaluate(
     3  16
     4  25
     """
-    env = env.with_outer_namespace(AES_INNER_NAMESPACE)
+    env = env.with_outer_namespace(EVAL_ENVIRONMENT)
 
     # Store evaluation results in a dict column in a dict
     evaled = {}

plotnine/plot_composition/_compose.py

@@ -283,11 +283,20 @@ class Compose:
             )
         return figure
 
-    def save(
-        self, filename: str | Path | BytesIO, save_format: str | None = None
-    ):
+    def save(self, filename: str | Path | BytesIO, format: str | None = None):
+        """
+        Save a Compose object as an image file
+
+        Parameters
+        ----------
+        filename :
+            File name to write the plot to. If not specified, a name
+        format :
+            Image format to use, automatically extract from
+            file name extension.
+        """
         figure = self.draw()
-        figure.savefig(filename, format=save_format)
+        figure.savefig(filename, format=format)
 
 
 @dataclass

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"}
 
@@ -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/element_text.py

@@ -164,6 +164,7 @@ class element_text(element_base):
             "size",
             "style",
             "va",
+            "ma",
             "weight",
             "rotation_mode",
         )

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.
     """
 

plotnine/themes/theme_gray.py

@@ -43,6 +43,7 @@ class theme_gray(theme):
                 family=base_family,
                 style="normal",
                 color="black",
+                ma="center",
                 size=base_size,
                 linespacing=0.9,
                 rotation=0,

plotnine/themes/themeable.py

@@ -811,7 +811,7 @@ class strip_text_x(MixinSequenceOfValues):
     theme_element : element_text
     """
 
-    _omit = ["margin"]
+    _omit = ["margin", "ha"]
 
     def apply_figure(self, figure: Figure, targets: ThemeTargets):
         super().apply_figure(figure, targets)
@@ -834,7 +834,7 @@ class strip_text_y(MixinSequenceOfValues):
     theme_element : element_text
     """
 
-    _omit = ["margin"]
+    _omit = ["margin", "va"]
 
     def apply_figure(self, figure: Figure, targets: ThemeTargets):
         super().apply_figure(figure, targets)
@@ -890,7 +890,7 @@ class axis_text_x(MixinSequenceOfValues):
     creates a margin of 5 points.
     """
 
-    _omit = ["margin"]
+    _omit = ["margin", "va"]
 
     def apply_ax(self, ax: Axes):
         super().apply_ax(ax)
@@ -923,7 +923,7 @@ class axis_text_y(MixinSequenceOfValues):
     creates a margin of 5 points.
     """
 
-    _omit = ["margin"]
+    _omit = ["margin", "ha"]
 
     def apply_ax(self, ax: Axes):
         super().apply_ax(ax)
@@ -1080,7 +1080,7 @@ class axis_ticks_minor_x(MixinSequenceOfValues):
         # to invisible. Theming should not change those artists to visible,
         # so we return early.
         params = ax.xaxis.get_tick_params(which="minor")
-        if not params.get("left", False):
+        if not params.get("bottom", False):
             return
 
         # We have to use both

{plotnine-0.15.0.dev1.dist-info → plotnine-0.15.0.dev3.dist-info}/METADATA

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