plotnine 0.15.0.dev3__py3-none-any.whl → 0.15.2__py3-none-any.whl

plotnine/_mpl/patches.py

@@ -4,12 +4,11 @@ from typing import TYPE_CHECKING
 
 from matplotlib import artist
 from matplotlib.patches import FancyBboxPatch, Rectangle
-from matplotlib.text import _get_textbox  # type: ignore
-from matplotlib.transforms import Affine2D
+from matplotlib.transforms import Bbox
 
-if TYPE_CHECKING:
-    from matplotlib.backend_bases import RendererBase
+from plotnine._mpl.utils import rel_position
 
+if TYPE_CHECKING:
     from plotnine.typing import StripPosition
 
     from .text import StripText
@@ -26,51 +25,88 @@ class StripTextPatch(FancyBboxPatch):
     Strip text background box
     """
 
-    # The text artists that is wrapped by this box
     text: StripText
+    """
+    The text artists that is wrapped by this box
+    """
+
     position: StripPosition
-    _update = False
+    """
+    The position of the strip_text associated with this patch
+    """
 
-    def __init__(self, text: StripText):
-        boxstyle = f"square, pad={text.draw_info.strip_text_margin}"
+    expand: float = 1
+    """
+    Factor by which to expand the thickness of this patch.
 
+    This value is used by the layout manager to increase the breadth
+    of the narrower strip_backgrounds.
+    """
+
+    def __init__(self, text: StripText):
         super().__init__(
-            (0, 0), 1, 1, boxstyle=boxstyle, clip_on=False, zorder=2.2
+            # The position, width and height are determine in
+            # .get_window_extent.
+            (0, 0),
+            width=1,
+            height=1,
+            boxstyle="square, pad=0",
+            clip_on=False,
+            zorder=2.2,
         )
 
         self.text = text
         self.position = text.draw_info.position
 
-    def update_position_size(self, renderer: RendererBase):
+    def get_window_extent(self, renderer=None):
         """
-        Update the location and the size of the bbox.
+        Location & dimensions of the box in display coordinates
         """
-        if self._update:
-            return
-
-        text = self.text
-        posx, posy = text.get_transform().transform(text.get_position())
-        x, y, w, h = _get_textbox(text, renderer)
-
-        self.set_bounds(0.0, 0.0, w, h)
-        self.set_transform(
-            Affine2D()
-            .rotate_deg(text.get_rotation())
-            .translate(posx + x, posy + y)
-        )
-        fontsize_in_pixel = renderer.points_to_pixels(
-            text.get_size()  # type: ignore
-        )
-        self.set_mutation_scale(fontsize_in_pixel)  # type: ignore
-        self._update = True
+        info = self.text.draw_info
+        m = info.margin
+
+        # bboxes in display space
+        text_bbox = self.text.get_window_extent(renderer)
+        ax_bbox = info.ax.bbox.frozen()
+
+        # line height in display space
+        line_height = self.text._line_height(renderer)
+
+        # Convert the bottom left coordinates of the patch  from
+        # transAxes to display space. We are not justifying the patch
+        # within the axes so we use 0 for the lengths, this gives us
+        # a patch that starts at the edge of the axes and not one that
+        # ends at the edge
+        x0 = rel_position(info.bg_x, 0, ax_bbox.x0, ax_bbox.x1)
+        y0 = rel_position(info.bg_y, 0, ax_bbox.y0, ax_bbox.y1)
+
+        # info.bg_width and info.bg_height are in axes space
+        # so they are a scaling factor
+        if info.position == "top":
+            width = ax_bbox.width * info.bg_width
+            height = text_bbox.height + ((m.b + m.t) * line_height)
+            height *= self.expand
+            y0 += height * info.strip_align
+        else:
+            height = ax_bbox.height * info.bg_height
+            width = text_bbox.width + ((m.l + m.r) * line_height)
+            width *= self.expand
+            x0 += width * info.strip_align
+
+        return Bbox.from_bounds(x0, y0, width, height)
 
-    def get_window_extent(self, renderer=None):
+    @artist.allow_rasterization
+    def draw(self, renderer):
         """
-        Location & dimensions of the box
+        Draw patch
         """
-        if renderer:
-            self.update_position_size(renderer)
-        return super().get_window_extent(renderer)
+        # The geometry of the patch is determined by its rectangular bounds,
+        # this is also its "window_extent". As the extent value is in
+        # display units, we don't need a transform.
+        bbox = self.get_window_extent(renderer)
+        self.set_bounds(bbox.bounds)
+        self.set_transform(None)
+        return super().draw(renderer)
 
 
 class InsideStrokedRectangle(Rectangle):

plotnine/_mpl/text.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+from functools import lru_cache
 from typing import TYPE_CHECKING
 
+from matplotlib import artist
 from matplotlib.text import Text
 
+from plotnine._utils import ha_as_float, va_as_float
+
 from .patches import StripTextPatch
 from .utils import bbox_in_axes_space, rel_position
 
@@ -11,7 +15,6 @@ if TYPE_CHECKING:
     from matplotlib.backend_bases import RendererBase
 
     from plotnine.iapi import strip_draw_info
-    from plotnine.typing import HorizontalJustification, VerticalJustification
 
 
 class StripText(Text):
@@ -28,86 +31,164 @@ class StripText(Text):
             "transform": info.ax.transAxes,
             "clip_on": False,
             "zorder": 3.3,
+            # Since the text can be rotated, it is simpler to anchor it at
+            # the center, align it, then do the rotation. Vertically,
+            # center_baseline places the text in the visual center, but
+            # only if it is one line. For multiline text, we are better
+            # off with plain center.
+            "ha": "center",
+            "va": "center_baseline" if info.is_oneline else "center",
+            "rotation_mode": "anchor",
         }
 
-        super().__init__(
-            info.x,
-            info.y,
-            info.label,
-            **kwargs,
-        )
+        super().__init__(0, 0, info.label, **kwargs)
         self.draw_info = info
         self.patch = StripTextPatch(self)
 
-    # TODO: Move these _justify methods to the layout manager
-    # We need to first make sure that the patch has the final size during
-    # layout computation. Right now, the final size is calculated during
-    # draw (in these justify methods)
-    def _justify_horizontally(self, renderer):
+    # TODO: This should really be part of the unit conversions in the
+    # margin class.
+    @lru_cache(2)
+    def _line_height(self, renderer) -> float:
+        """
+        The line height in display space of the text on the canvas
+        """
+        # Text string, (width, height), x, y
+        parts: list[tuple[str, tuple[float, float], float, float]]
+
+        try:
+            # matplotlib.Text._get_layout is a private API and we cannot
+            # tell how using it may fail in the future.
+            _, parts, _ = self._get_layout(renderer)  # pyright: ignore[reportAttributeAccessIssue]
+        except Exception:
+            from warnings import warn
+
+            from plotnine.exceptions import PlotnineWarning
+
+            # The canvas height is nearly always bigger than the stated
+            # fontsize. 1.36 is a good multiplication factor obtained by
+            # some rough exploration
+            f = 1.36
+            size = self.get_fontsize()
+            height = round(size * f) if isinstance(size, int) else 14
+            warn(
+                f"Could not calculate line height for {self.get_text()}. "
+                "Using an estimate, please let us know about this at "
+                "https://github.com/has2k1/plotnine/issues",
+                PlotnineWarning,
+            )
+        else:
+            # The the text has multiple lines, we use the maximum height
+            # of anyone single line.
+            height = max([p[1][1] for p in parts])
+
+        return height
+
+    def _set_position(self, renderer):
+        """
+        Set the postion of the text within the strip_background
+        """
+        # We have to two premises that depend on each other:
+        #
+        #    1. The breadth of the strip_background grows to accomodate
+        #       the strip_text.
+        #    2. The strip_text is justified within the strip_background.
+        #
+        # From these we note that the strip_background does not need the
+        # position of the strip_text, but it needs its size. Therefore
+        # we implement StripTextPatch.get_window_extent can use
+        # StripText.get_window_extent, peeking only at the size.
+        #
+        # And we implement StripText._set_position_* to use
+        # StripTextPatch.get_window_extent and make the calculations in
+        # both methods independent.
+        if self.draw_info.position == "top":
+            self._set_position_top(renderer)
+        else:  # "right"
+            self._set_position_right(renderer)
+
+    def _set_position_top(self, renderer):
         """
-        Justify the text along the strip_background
+        Set position of the text within the top strip_background
         """
         info = self.draw_info
-        lookup: dict[HorizontalJustification, float] = {
-            "left": 0.0,
-            "center": 0.5,
-            "right": 1.0,
-        }
-        rel = lookup.get(info.ha, 0.5) if isinstance(info.ha, str) else info.ha
-        patch_bbox = bbox_in_axes_space(self.patch, info.ax, renderer)
-        text_bbox = bbox_in_axes_space(self, info.ax, renderer)
-        l, b, w, h = info.x, info.y, info.box_width, patch_bbox.height
-        b = b + patch_bbox.height * info.strip_align
-        x = rel_position(rel, text_bbox.width, patch_bbox.x0, patch_bbox.x1)
-        y = b + h / 2
-        self.set_horizontalalignment("left")
-        self.patch.set_bounds(l, b, w, h)
+        ha, va, ax, m = info.ha, info.va, info.ax, info.margin
+
+        rel_x, rel_y = ha_as_float(ha), va_as_float(va)
+        patch_bbox = bbox_in_axes_space(self.patch, ax, renderer)
+        text_bbox = bbox_in_axes_space(self, ax, renderer)
+
+        # line_height and margins in axes space
+        line_height = self._line_height(renderer) / ax.bbox.height
+
+        x = (
+            # Justify horizontally within the strip_background
+            rel_position(
+                rel_x,
+                text_bbox.width + (line_height * (m.l + m.r)),
+                patch_bbox.x0,
+                patch_bbox.x1,
+            )
+            + (m.l * line_height)
+            + text_bbox.width / 2
+        )
+        # Setting the y position based on the bounding box is wrong
+        y = (
+            rel_position(
+                rel_y,
+                text_bbox.height,
+                patch_bbox.y0 + m.b * line_height,
+                patch_bbox.y1 - m.t * line_height,
+            )
+            + text_bbox.height / 2
+        )
         self.set_position((x, y))
 
-    def _justify_vertically(self, renderer):
+    def _set_position_right(self, renderer):
         """
-        Justify the text along the strip_background
+        Set position of the text within the bottom strip_background
         """
-        # Note that the strip text & background and horizontal but
-        # rotated to appear vertical. So we really are still justifying
-        # horizontally.
         info = self.draw_info
-        lookup: dict[VerticalJustification, float] = {
-            "bottom": 0.0,
-            "center": 0.5,
-            "top": 1.0,
-        }
-        rel = lookup.get(info.va, 0.5) if isinstance(info.va, str) else info.va
-        patch_bbox = bbox_in_axes_space(self.patch, info.ax, renderer)
-        text_bbox = bbox_in_axes_space(self, info.ax, renderer)
-        l, b, w, h = info.x, info.y, patch_bbox.width, info.box_height
-        l = l + patch_bbox.width * info.strip_align
-        x = l + w / 2
-        y = rel_position(rel, text_bbox.height, patch_bbox.y0, patch_bbox.y1)
-        self.set_horizontalalignment("right")  # 90CW right means bottom
-        self.patch.set_bounds(l, b, w, h)
-        self.set_position((x, y))
+        ha, va, ax, m = info.ha, info.va, info.ax, info.margin
 
-    def draw(self, renderer: RendererBase):
-        if not self.get_visible():
-            return
+        # bboxes in axes space
+        patch_bbox = bbox_in_axes_space(self.patch, ax, renderer)
+        text_bbox = bbox_in_axes_space(self, ax, renderer)
 
-        # expand strip_text patch to contain the text
-        self.patch.update_position_size(renderer)
+        # line_height in axes space
+        line_height = self._line_height(renderer) / ax.bbox.width
 
-        # Align patch across the edge of the panel
-        if self.draw_info.position == "top":
-            self._justify_horizontally(renderer)
-        else:  # "right"
-            self._justify_vertically(renderer)
+        rel_x, rel_y = ha_as_float(ha), va_as_float(va)
 
-        self.patch.set_transform(self.draw_info.ax.transAxes)
-        self.patch.set_mutation_scale(0)
+        x = (
+            rel_position(
+                rel_x,
+                text_bbox.width,
+                patch_bbox.x0 + m.l * line_height,
+                patch_bbox.x1 - m.r * line_height,
+            )
+            + text_bbox.width / 2
+        )
+        y = (
+            # Justify vertically within the strip_background
+            rel_position(
+                rel_y,
+                text_bbox.height + ((m.b + m.t) * line_height),
+                patch_bbox.y0,
+                patch_bbox.y1,
+            )
+            + (m.b * line_height)
+            + text_bbox.height / 2
+        )
+        self.set_position((x, y))
 
-        # Put text in center of patch
-        self.set_rotation_mode("anchor")
-        self.set_verticalalignment("center_baseline")
+    @artist.allow_rasterization
+    def draw(self, renderer: RendererBase):
+        """
+        Draw text along with the patch
+        """
+        if not self.get_visible():
+            return
 
-        # Draw spatch
+        self._set_position(renderer)
         self.patch.draw(renderer)
         return super().draw(renderer)

plotnine/_mpl/utils.py

@@ -139,7 +139,7 @@ def draw_bbox(bbox, figure, color="black", **kwargs):
             width=bbox.width,
             height=bbox.height,
             edgecolor=color,
-            fill=False,
+            fill="facecolor" in kwargs,
             clip_on=False,
             **kwargs,
         )

plotnine/_utils/__init__.py

@@ -12,9 +12,10 @@ from collections.abc import Iterable, Sequence
 from contextlib import suppress
 from copy import deepcopy
 from dataclasses import field
-from typing import TYPE_CHECKING, cast, overload
+from typing import TYPE_CHECKING
 from warnings import warn
 
+import mizani._colors.utils as color_utils
 import numpy as np
 import pandas as pd
 from pandas.core.groupby import DataFrameGroupBy
@@ -26,17 +27,17 @@ if TYPE_CHECKING:
     from typing import Any, Callable, Literal, TypeVar
 
     import numpy.typing as npt
-    from matplotlib.typing import ColorType
     from typing_extensions import TypeGuard
 
     from plotnine.typing import (
         AnyArrayLike,
-        AnySeries,
         DataLike,
         FloatArray,
         FloatArrayLike,
+        HorizontalJustification,
         IntArray,
-        SidePosition,
+        Side,
+        VerticalJustification,
     )
 
     T = TypeVar("T")
@@ -58,6 +59,8 @@ BOX_LOCATIONS: dict[str, tuple[float, float]] = {
     "centre": (0.5, 0.5),
 }
 
+to_rgba = color_utils.to_rgba
+
 
 def is_scalar(val):
     """
@@ -344,6 +347,8 @@ def _id_var(x: AnyArrayLike, drop: bool = False) -> list[int]:
                 # NaNs are -1, we give them the highest code
                 nan_code = -1
                 new_nan_code = np.max(x.cat.codes) + 1
+                # TODO: We are assuming that x is of type Sequence[int|nan]
+                # is that accurate.
                 lst = [val if val != nan_code else new_nan_code for val in x]
             else:
                 lst = list(x.cat.codes + 1)
@@ -511,7 +516,7 @@ def remove_missing(
     if finite:
         lst = [np.inf, -np.inf]
         to_replace = {v: lst for v in vars}
-        data.replace(to_replace, np.nan, inplace=True)  # pyright: ignore[reportArgumentType,reportCallIssue]
+        data.replace(to_replace, np.nan, inplace=True)
         txt = "non-finite"
     else:
         txt = "missing"
@@ -526,105 +531,6 @@ def remove_missing(
     return data
 
 
-@overload
-def to_rgba(colors: ColorType, alpha: float) -> ColorType: ...
-
-
-@overload
-def to_rgba(
-    colors: Sequence[ColorType], alpha: float
-) -> Sequence[ColorType] | ColorType: ...
-
-
-@overload
-def to_rgba(
-    colors: AnySeries, alpha: AnySeries
-) -> Sequence[ColorType] | ColorType: ...
-
-
-def to_rgba(
-    colors: Sequence[ColorType] | AnySeries | ColorType,
-    alpha: float | Sequence[float] | AnySeries,
-) -> Sequence[ColorType] | ColorType:
-    """
-    Convert hex colors to rgba values.
-
-    Parameters
-    ----------
-    colors : iterable | str
-        colors to convert
-    alphas : iterable | float
-        alpha values
-
-    Returns
-    -------
-    out : ndarray | tuple
-        rgba color(s)
-
-    Notes
-    -----
-    Matplotlib plotting functions only accept scalar
-    alpha values. Hence no two objects with different
-    alpha values may be plotted in one call. This would
-    make plots with continuous alpha values innefficient.
-    However :), the colors can be rgba hex values or
-    list-likes and the alpha dimension will be respected.
-    """
-
-    def is_iterable(var):
-        return np.iterable(var) and not isinstance(var, str)
-
-    def has_alpha(c):
-        return (isinstance(c, tuple) and len(c) == 4) or (
-            isinstance(c, str) and len(c) == 9 and c[0] == "#"
-        )
-
-    def no_color(c):
-        return c is None or c.lower() in ("none", "")
-
-    def to_rgba_hex(c: ColorType, a: float) -> str:
-        """
-        Convert rgb color to rgba hex value
-
-        If color c has an alpha channel, then alpha value
-        a is ignored
-        """
-        from matplotlib.colors import colorConverter, to_hex
-
-        if c in ("None", "none"):
-            return c
-
-        _has_alpha = has_alpha(c)
-        c = to_hex(c, keep_alpha=_has_alpha)
-
-        if not _has_alpha:
-            arr = colorConverter.to_rgba(c, a)
-            return to_hex(arr, keep_alpha=True)
-
-        return c
-
-    if is_iterable(colors):
-        colors = cast("Sequence[ColorType]", colors)
-
-        if all(no_color(c) for c in colors):
-            return "none"
-
-        if isinstance(alpha, (Sequence, pd.Series)):
-            return [to_rgba_hex(c, a) for c, a in zip(colors, alpha)]
-        else:
-            return [to_rgba_hex(c, alpha) for c in colors]
-    else:
-        colors = cast("ColorType", colors)
-
-        if no_color(colors):
-            return colors
-
-        if isinstance(alpha, (Sequence, pd.Series)):
-            return [to_rgba_hex(colors, a) for a in alpha]
-        else:
-            return to_rgba_hex(colors, alpha)
-
-
 def groupby_apply(
     df: pd.DataFrame,
     cols: str | list[str],
@@ -1227,11 +1133,11 @@ def default_field(default: T) -> T:
     return field(default_factory=lambda: deepcopy(default))
 
 
-def get_opposite_side(s: SidePosition) -> SidePosition:
+def get_opposite_side(s: Side) -> Side:
     """
     Return the opposite side
     """
-    lookup: dict[SidePosition, SidePosition] = {
+    lookup: dict[Side, Side] = {
         "right": "left",
         "left": "right",
         "top": "bottom",
@@ -1241,7 +1147,7 @@ def get_opposite_side(s: SidePosition) -> SidePosition:
 
 
 def ensure_xy_location(
-    loc: SidePosition | Literal["center"] | float | tuple[float, float],
+    loc: Side | Literal["center"] | float | tuple[float, float],
 ) -> tuple[float, float]:
     """
     Convert input into (x, y) location
@@ -1264,3 +1170,40 @@ def ensure_xy_location(
         if isinstance(h, (int, float)) and isinstance(v, (int, float)):
             return (h, v)
     raise ValueError(f"Cannot make a location from '{loc}'")
+
+
+def ha_as_float(ha: HorizontalJustification | float) -> float:
+    """
+    Return horizontal alignment as a float
+    """
+    lookup = {"left": 0.0, "center": 0.5, "right": 1.0}
+    return lookup[ha] if isinstance(ha, str) else ha
+
+
+def va_as_float(va: VerticalJustification | float) -> float:
+    """
+    Return vertical alignment as a float
+    """
+    lookup = {
+        "top": 1.0,
+        "center": 0.5,
+        "bottom": 0.0,
+        # baseline and center_baseline are valid for texts but we do
+        # not handle them accurately
+        "baseline": 0.5,
+        "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