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

plotnine/_mpl/layout_manager/_layout_items.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING, cast
 
 from matplotlib.text import Text
 
+from plotnine._mpl.patches import StripTextPatch
+from plotnine._utils import ha_as_float, va_as_float
 from plotnine.exceptions import PlotnineError
 
 from ..utils import (
@@ -35,7 +37,11 @@ if TYPE_CHECKING:
     from plotnine._mpl.text import StripText
     from plotnine.iapi import legend_artists
     from plotnine.themes.elements import margin as Margin
-    from plotnine.typing import StripPosition
+    from plotnine.typing import (
+        HorizontalJustification,
+        StripPosition,
+        VerticalJustification,
+    )
 
     from ._spaces import LayoutSpaces
 
@@ -299,9 +305,9 @@ class LayoutItems:
 
         return chain(major, minor)
 
-    def strip_text_x_height(self, position: StripPosition) -> float:
+    def strip_text_x_extra_height(self, position: StripPosition) -> float:
         """
-        Height taken up by the top strips
+        Height taken up by the top strips that is outside the panels
         """
         if not self.strip_text_x:
             return 0
@@ -311,11 +317,23 @@ class LayoutItems:
             for st in self.strip_text_x
             if st.patch.position == position
         ]
-        return self.calc.max_height(artists)
 
-    def strip_text_y_width(self, position: StripPosition) -> float:
+        heights = []
+
+        for a in artists:
+            info = (
+                a.text.draw_info
+                if isinstance(a, StripTextPatch)
+                else a.draw_info
+            )
+            h = self.calc.height(a)
+            heights.append(max(h + h * info.strip_align, 0))
+
+        return max(heights)
+
+    def strip_text_y_extra_width(self, position: StripPosition) -> float:
         """
-        Width taken up by the right strips
+        Width taken up by the top strips that is outside the panels
         """
         if not self.strip_text_y:
             return 0
@@ -325,7 +343,19 @@ class LayoutItems:
             for st in self.strip_text_y
             if st.patch.position == position
         ]
-        return self.calc.max_width(artists)
+
+        widths = []
+
+        for a in artists:
+            info = (
+                a.text.draw_info
+                if isinstance(a, StripTextPatch)
+                else a.draw_info
+            )
+            w = self.calc.width(a)
+            widths.append(max(w + w * info.strip_align, 0))
+
+        return max(widths)
 
     def axis_ticks_x_max_height_at(self, location: AxesLocation) -> float:
         """
@@ -489,6 +519,8 @@ class LayoutItems:
 
         self._adjust_axis_text_x(justify)
         self._adjust_axis_text_y(justify)
+        self._strip_text_x_background_equal_heights()
+        self._strip_text_y_background_equal_widths()
 
     def _adjust_axis_text_x(self, justify: TextJustifier):
         """
@@ -574,6 +606,36 @@ class LayoutItems:
                     text, ha, -axis_text_col_width, 0, width=width
                 )
 
+    def _strip_text_x_background_equal_heights(self):
+        """
+        Make the strip_text_x_backgrounds have equal heights
+
+        The smaller heights are expanded to match the largest height
+        """
+        if not self.strip_text_x:
+            return
+
+        heights = [self.calc.bbox(t.patch).height for t in self.strip_text_x]
+        max_height = max(heights)
+        relative_heights = [max_height / h for h in heights]
+        for text, scale in zip(self.strip_text_x, relative_heights):
+            text.patch.expand = scale
+
+    def _strip_text_y_background_equal_widths(self):
+        """
+        Make the strip_text_y_backgrounds have equal widths
+
+        The smaller widths are expanded to match the largest width
+        """
+        if not self.strip_text_y:
+            return
+
+        widths = [self.calc.bbox(t.patch).width for t in self.strip_text_y]
+        max_width = max(widths)
+        relative_widths = [max_width / w for w in widths]
+        for text, scale in zip(self.strip_text_y, relative_widths):
+            text.patch.expand = scale
+
 
 def _text_is_visible(text: Text) -> bool:
     """
@@ -596,7 +658,7 @@ class TextJustifier:
     def horizontally(
         self,
         text: Text,
-        ha: str | float,
+        ha: HorizontalJustification | float,
         left: float,
         right: float,
         width: float | None = None,
@@ -604,8 +666,7 @@ class TextJustifier:
         """
         Horizontally Justify text between left and right
         """
-        lookup = {"left": 0.0, "center": 0.5, "right": 1.0}
-        rel = lookup.get(ha, ha)  # pyright: ignore[reportCallIssue, reportArgumentType]
+        rel = ha_as_float(ha)
         if width is None:
             width = self.spaces.items.calc.width(text)
         x = rel_position(rel, width, left, right)
@@ -615,7 +676,7 @@ class TextJustifier:
     def vertically(
         self,
         text: Text,
-        va: str | float,
+        va: VerticalJustification | float,
         bottom: float,
         top: float,
         height: float | None = None,
@@ -623,14 +684,7 @@ class TextJustifier:
         """
         Vertically Justify text between bottom and top
         """
-        lookup = {
-            "top": 1.0,
-            "center": 0.5,
-            "baseline": 0.5,
-            "center_baseline": 0.5,
-            "bottom": 0.0,
-        }
-        rel = lookup.get(va, va)  # pyright: ignore[reportCallIssue, reportArgumentType]
+        rel = va_as_float(va)
 
         if height is None:
             height = self.spaces.items.calc.height(text)
@@ -638,13 +692,17 @@ class TextJustifier:
         text.set_y(y)
         text.set_verticalalignment("bottom")
 
-    def horizontally_across_panel(self, text: Text, ha: str | float):
+    def horizontally_across_panel(
+        self, text: Text, ha: HorizontalJustification | float
+    ):
         """
         Horizontally Justify text accross the panel(s) width
         """
         self.horizontally(text, ha, self.spaces.l.left, self.spaces.r.right)
 
-    def horizontally_across_plot(self, text: Text, ha: str | float):
+    def horizontally_across_plot(
+        self, text: Text, ha: HorizontalJustification | float
+    ):
         """
         Horizontally Justify text across the plot's width
         """
@@ -652,13 +710,17 @@ class TextJustifier:
             text, ha, self.spaces.l.plot_left, self.spaces.r.plot_right
         )
 
-    def vertically_along_panel(self, text: Text, va: str | float):
+    def vertically_along_panel(
+        self, text: Text, va: VerticalJustification | float
+    ):
         """
         Horizontally Justify text along the panel(s) height
         """
         self.vertically(text, va, self.spaces.b.bottom, self.spaces.t.top)
 
-    def vertically_along_plot(self, text: Text, va: str | float):
+    def vertically_along_plot(
+        self, text: Text, va: VerticalJustification | float
+    ):
         """
         Vertically Justify text along the plot's height
         """

plotnine/_mpl/layout_manager/_layout_tree.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import abc
 from dataclasses import dataclass
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
 
@@ -528,8 +528,9 @@ class ColumnsTree(LayoutTree):
         if self.bottom_tags_align:
             return
 
-        values = max(self.bottom_tag_heights) - np.array(
-            self.bottom_tag_heights
+        values = cast(
+            "Sequence[float]",
+            max(self.bottom_tag_heights) - np.array(self.bottom_tag_heights),
         )
         for item, value in zip(self.nodes, values):
             if isinstance(item, LayoutSpaces):
@@ -541,7 +542,10 @@ class ColumnsTree(LayoutTree):
         if self.top_tags_align:
             return
 
-        values = max(self.top_tag_heights) - np.array(self.top_tag_heights)
+        values = cast(
+            "Sequence[float]",
+            max(self.top_tag_heights) - np.array(self.top_tag_heights),
+        )
         for item, value in zip(self.nodes, values):
             if isinstance(item, LayoutSpaces):
                 item.t.tag_alignment = value
@@ -776,7 +780,10 @@ class RowsTree(LayoutTree):
         if self.left_tags_align:
             return
 
-        values = max(self.left_tag_widths) - np.array(self.left_tag_widths)
+        values = cast(
+            "Sequence[float]",
+            max(self.left_tag_widths) - np.array(self.left_tag_widths),
+        )
         for item, value in zip(self.nodes, values):
             if isinstance(item, LayoutSpaces):
                 item.l.tag_alignment = value
@@ -787,7 +794,10 @@ class RowsTree(LayoutTree):
         if self.right_tags_align:
             return
 
-        values = max(self.right_tag_widths) - np.array(self.right_tag_widths)
+        values = cast(
+            "Sequence[float]",
+            max(self.right_tag_widths) - np.array(self.right_tag_widths),
+        )
         for item, value in zip(self.nodes, values):
             if isinstance(item, LayoutSpaces):
                 item.r.tag_alignment = value

plotnine/_mpl/layout_manager/_spaces.py

@@ -433,7 +433,7 @@ class right_spaces(_side_spaces):
     margin_alignment: float = 0
     legend: float = 0
     legend_box_spacing: float = 0
-    strip_text_y_width_right: float = 0
+    strip_text_y_extra_width: float = 0
 
     def _calculate(self):
         items = self.items
@@ -452,7 +452,7 @@ class right_spaces(_side_spaces):
             self.legend = self.legend_width
             self.legend_box_spacing = theme.getp("legend_box_spacing")
 
-        self.strip_text_y_width_right = items.strip_text_y_width("right")
+        self.strip_text_y_extra_width = items.strip_text_y_extra_width("right")
 
         # Adjust plot_margin to make room for ylabels that protude well
         # beyond the axes
@@ -545,7 +545,7 @@ class top_spaces(_side_spaces):
     plot_subtitle_margin_bottom: float = 0
     legend: float = 0
     legend_box_spacing: float = 0
-    strip_text_x_height_top: float = 0
+    strip_text_x_extra_height: float = 0
 
     def _calculate(self):
         items = self.items
@@ -578,7 +578,7 @@ class top_spaces(_side_spaces):
             self.legend = self.legend_height
             self.legend_box_spacing = theme.getp("legend_box_spacing") * F
 
-        self.strip_text_x_height_top = items.strip_text_x_height("top")
+        self.strip_text_x_extra_height = items.strip_text_x_extra_height("top")
 
         # Adjust plot_margin to make room for ylabels that protude well
         # beyond the axes
@@ -1061,7 +1061,7 @@ class LayoutSpaces:
         # Only interested in the proportion of the strip that
         # does not overlap with the panel
         if strip_align_x > -1:
-            self.sh += self.t.strip_text_x_height_top * (1 + strip_align_x)
+            self.sh += self.t.strip_text_x_extra_height * (1 + strip_align_x)
 
         if facet.free["x"]:
             self.sh += self.items.axis_text_x_max_height_at(

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):