fix(layout): shift each strip past its own panel's axis

For strip_placement="outside" the strips of a group were all shifted
by the plot-edge axis band, so a panel that draws no axis on the
strip's side (fixed scales, multi-row facets) got its strip floated
outward to clear an axis that is not there — and the interior gullies
were sized for strips that hug their panels, letting shifted strips
overlap the panel below. Each strip now clears exactly the ticks,
labels and panel-facing margin its own panel draws on that side
(PlotLayoutItems.strip_shift); the side-level strip_band_offset keeps
only its axis member, used for strip_placement="inside".

Author: has2k1

plotnine/_mpl/layout_manager/_plot_layout_items.py

@@ -348,21 +348,65 @@ def strip_text_y(self, position: StripPosition) -> float:
 
         return max(widths) if widths else 0
 
-    def axis_ticks_x_max_height_at(
-        self, location: AxesLocation, side: str
-    ) -> float:
+    def strip_shift(self, st: StripText) -> float:
+        """
+        Outward shift of one strip past its own panel's axis, figure space
+
+        For `strip_placement="outside"` a strip sits beyond the ticks,
+        tick labels and panel-facing text margin that its own panel draws
+        on the strip's side, separated by the strip_switch_pad. A panel
+        that draws no axis on that side keeps its strip next to the
+        panel, so within one facet the strips of axis-bearing panels
+        shift while the others do not.
+        """
+        theme = self.plot.theme
+        if theme.getp("strip_placement") != "outside":
+            return 0
+        side, ax = st.position, st.ax
+        W, H = theme.getp("figure_size")
+        if side in ("top", "bottom"):
+            g, dim = "x", H
+            text = self.axis_text_x_max_height(ax, side)
+            ticks = self.axis_ticks_x_max_height(ax, side)
+            facing = "b" if side == "top" else "t"
+        else:
+            g, dim = "y", W
+            text = self.axis_text_y_max_width(ax, side)
+            ticks = self.axis_ticks_y_max_width(ax, side)
+            facing = "r" if side == "left" else "l"
+        band = text + ticks
+        if text:
+            m = theme.get_margin(f"axis_text_{g}_{side}").fig
+            band += getattr(m, facing)
+        if not band:
+            return 0
+        pad_pt = theme.getp(f"strip_switch_pad_{g}") or 0
+        return band + (pad_pt / 72) / dim
+
+    def axis_ticks_x_max_height(self, ax: Axes, side: str) -> float:
         """
         Return maximum height[figure space] of visible x ticks on a side
         """
         attr = side_artists(side)[0]
         heights = [
             self.geometry.tight_height(getattr(tick, attr))
-            for ax in self._filter_axes(location)
             for tick in self.axis_ticks_x(ax)
             if getattr(tick, attr).get_visible()
         ]
         return max(heights) if len(heights) else 0
 
+    def axis_ticks_x_max_height_at(
+        self, location: AxesLocation, side: str
+    ) -> float:
+        """
+        Return maximum height[figure space] of visible x ticks on a side
+        """
+        heights = [
+            self.axis_ticks_x_max_height(ax, side)
+            for ax in self._filter_axes(location)
+        ]
+        return max(heights) if len(heights) else 0
+
     def axis_text_x_max_height(self, ax: Axes, side: str) -> float:
         """
         Return maximum height[figure space] of x tick labels on a side
@@ -385,21 +429,30 @@ def axis_text_x_max_height_at(
         ]
         return max(heights) if len(heights) else 0
 
-    def axis_ticks_y_max_width_at(
-        self, location: AxesLocation, side: str
-    ) -> float:
+    def axis_ticks_y_max_width(self, ax: Axes, side: str) -> float:
         """
         Return maximum width[figure space] of visible y ticks on a side
         """
         attr = side_artists(side)[0]
         widths = [
             self.geometry.tight_width(getattr(tick, attr))
-            for ax in self._filter_axes(location)
             for tick in self.axis_ticks_y(ax)
             if getattr(tick, attr).get_visible()
         ]
         return max(widths) if len(widths) else 0
 
+    def axis_ticks_y_max_width_at(
+        self, location: AxesLocation, side: str
+    ) -> float:
+        """
+        Return maximum width[figure space] of visible y ticks on a side
+        """
+        widths = [
+            self.axis_ticks_y_max_width(ax, side)
+            for ax in self._filter_axes(location)
+        ]
+        return max(widths) if len(widths) else 0
+
     def axis_text_y_max_width(self, ax: Axes, side: str) -> float:
         """
         Return maximum width[figure space] of y tick labels on a side
@@ -552,7 +605,7 @@ def _move_artists(self, spaces: PlotSideSpaces):
         self._adjust_axis_text_x(justify, spaces)
         self._adjust_axis_text_y(justify, spaces)
         self._position_strip_band_axes(spaces)
-        self._position_strip_backgrounds(spaces)
+        self._position_strip_backgrounds()
 
     def _adjust_axis_text_x(
         self, justify: TextJustifier, spaces: PlotSideSpaces
@@ -575,8 +628,8 @@ def to_vertical_axis_dimensions(value: float, ax: Axes) -> float:
         # For strip_placement="inside", an axis sharing its side with a
         # strip is pushed past the strip; zero otherwise.
         band_offsets = {
-            "bottom": spaces.b.strip_band_offset("axis"),
-            "top": spaces.t.strip_band_offset("axis"),
+            "bottom": spaces.b.strip_band_offset(),
+            "top": spaces.t.strip_band_offset(),
         }
 
         for side in ("bottom", "top"):
@@ -647,8 +700,8 @@ def to_horizontal_axis_dimensions(value: float, ax: Axes) -> float:
         # For strip_placement="inside", an axis sharing its side with a
         # strip is pushed past the strip; zero otherwise.
         band_offsets = {
-            "left": spaces.l.strip_band_offset("axis"),
-            "right": spaces.r.strip_band_offset("axis"),
+            "left": spaces.l.strip_band_offset(),
+            "right": spaces.r.strip_band_offset(),
         }
 
         for side in ("left", "right"):
@@ -690,10 +743,10 @@ def _position_strip_band_axes(self, spaces: PlotSideSpaces):
         to_points = 72 / fig.dpi
         W, H = fig.bbox.width, fig.bbox.height
         offsets = {
-            "top": spaces.t.strip_band_offset("axis") * H,
-            "bottom": spaces.b.strip_band_offset("axis") * H,
-            "left": spaces.l.strip_band_offset("axis") * W,
-            "right": spaces.r.strip_band_offset("axis") * W,
+            "top": spaces.t.strip_band_offset() * H,
+            "bottom": spaces.b.strip_band_offset() * H,
+            "left": spaces.l.strip_band_offset() * W,
+            "right": spaces.r.strip_band_offset() * W,
         }
         for ax in self.plot.axs:
             for side, offset in offsets.items():
@@ -718,33 +771,33 @@ def _strip_breadth_scales(
         largest = max(natural)
         return [largest / b for b in natural]
 
-    def _position_strip_backgrounds(self, spaces: PlotSideSpaces):
+    def _position_strip_backgrounds(self):
         """
         Fix each strip background at its final bounds and place its text
 
-        When `strip_placement="outside"` and a moved axis shares the
-        strip's side, the strip is shifted outward to clear the axis.
+        When `strip_placement="outside"`, each strip is shifted outward
+        to clear the axis its own panel draws on the strip's side.
         """
         theme = self.plot.theme
         groups = (
-            (self.strip_text_x_top or [], spaces.t),
-            (self.strip_text_x_bottom or [], spaces.b),
-            (self.strip_text_y_right or [], spaces.r),
-            (self.strip_text_y_left or [], spaces.l),
+            self.strip_text_x_top or [],
+            self.strip_text_x_bottom or [],
+            self.strip_text_y_right or [],
+            self.strip_text_y_left or [],
         )
-        for group, space in groups:
+        for group in groups:
             if not group:
                 continue
-            offset = space.strip_band_offset("strip")
             breadth = StripSpec.make(group[0], theme).breadth
             scales = self._strip_breadth_scales(group, breadth)
             for st, scale in zip(group, scales):
                 spec = StripSpec.make(st, theme)
                 x0, y0, w, h = self.strip_patch_bbox(st, scale).bounds
+                shift = self.strip_shift(st)
                 if spec.axis == "x":
-                    y0 += spec.sign * offset
+                    y0 += spec.sign * shift
                 else:
-                    x0 += spec.sign * offset
+                    x0 += spec.sign * shift
                 st.patch.set_bounds((x0, y0, w, h))
                 self._position_strip_text(st)
 

plotnine/_mpl/layout_manager/_plot_side_space.py

@@ -171,33 +171,30 @@ def _strip_switch_pad(self, axis: Literal["x", "y"]) -> float:
         dim = H if axis == "x" else W
         return (pad_pt / 72) / dim
 
-    def strip_band_offset(self, member: Literal["strip", "axis"]) -> float:
+    def strip_band_offset(self) -> float:
         """
-        Outward offset for one member of a shared strip/axis band
+        Outward offset of the axis within a shared strip/axis band
 
         When a facet strip and an axis occupy the same side, the band is
         ordered from the panel outward. `strip_placement` chooses the order:
 
             "inside":   panel | strip | ticks+labels | title
             "outside":  panel | ticks+labels | strip | title
 
-        `member` is `"strip"` (the strip background + text) or `"axis"` (the
-        ticks and tick labels). The offset is produced here in figure space and
-        consumed per artist in its own coordinate system: the title in figure
-        space, the tick labels in axes fractions, the spine in points.
+        For `"inside"` the axis (ticks and tick labels) clears the strip,
+        so the offset is the strip breadth; for `"outside"` the axis stays
+        at the panel and each strip clears its own panel's axis instead
+        (`PlotLayoutItems.strip_shift`). The offset is produced here in
+        figure space and consumed per artist in its own coordinate system:
+        the tick labels in axes fractions, the spine in points.
 
         The offset is zero unless the side carries both a strip and an axis.
         """
         strip_breadth: float = self.strip_text  # pyright: ignore[reportAttributeAccessIssue]
-        axis_breadth = self._axis_ticks_and_text
-        if not (strip_breadth and axis_breadth):
+        if not (strip_breadth and self._axis_ticks_and_text):
             return 0
         placement = self.items.plot.theme.getp("strip_placement")
-        if placement == "inside":
-            return 0 if member == "strip" else strip_breadth
-        # "outside": the strip clears the axis, plus the switch pad
-        pad: float = self.strip_switch_pad  # pyright: ignore[reportAttributeAccessIssue]
-        return axis_breadth + pad if member == "strip" else 0
+        return strip_breadth if placement == "inside" else 0
 
 
 class left_space(_plot_side_space):

tests/test_strip_placement.py

@@ -36,6 +36,18 @@ def test_facet_wrap_top_outside():
     assert p1 == "facet_wrap_top_outside"
 
 
+def test_facet_wrap_top_outside_two_rows():
+    # A panel that draws no axis on the strip's side keeps its strip
+    # next to the panel; only axis-bearing panels shift theirs.
+    p1 = (
+        p
+        + facet_wrap("cyl", nrow=2)
+        + scale_x_continuous(position="top")
+        + theme(strip_placement="outside")
+    )
+    assert p1 == "facet_wrap_top_outside_two_rows"
+
+
 def test_facet_grid_top_inside():
     p1 = p + facet_grid("am", "cyl") + scale_x_continuous(position="top")
     assert p1 == "facet_grid_top_inside"