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

plotnine/_mpl/layout_manager/_layout_tree.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import abc
-from contextlib import suppress
 from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING
@@ -81,6 +80,13 @@ class LayoutTree:
     represents.
     """
 
+    @cached_property
+    def sub_compositions(self) -> list[LayoutTree]:
+        """
+        LayoutTrees of the direct sub compositions of this one
+        """
+        return [item for item in self.nodes if isinstance(item, LayoutTree)]
+
     @cached_property
     @abc.abstractmethod
     def lefts(self) -> Sequence[float]:
@@ -141,89 +147,54 @@ class LayoutTree:
         In figure dimenstions
         """
 
-    def align_lefts(self):
+    @abc.abstractmethod
+    def align(self):
         """
-        Align the immediate left edges in this composition
+        Align all the edges in this composition & contained compositions
 
-         -----------        -----------
-        |#          |      |  #        |
-        |#          |      |  #        |
-        |#          |      |  #        |
-        |-----------|  ->  |-----------|
-        |  #        |      |  #        |
-        |  #        |      |  #        |
-        |  #        |      |  #        |
-         -----------        -----------
+        This function mutates the layout spaces, specifically the
+        alignment_margins along the sides of the plot.
         """
 
-    def align_bottoms(self):
+    def align_sub_compositions(self):
         """
-        Align the immediate bottom edges this composition
-
-         -----------        -----------
-        |     |     |      |     |     |
-        |     |     |      |     |     |
-        |     |     |  ->  |     |     |
-        |     |#####|      |#####|#####|
-        |#####|     |      |     |     |
-         -----------        -----------
+        Align the compositions contained in this one
         """
+        # Recurse into the contained compositions
+        for tree in self.sub_compositions:
+            tree.align()
 
-    def align_rights(self):
+    @property
+    def bottoms_align(self) -> bool:
         """
-        Align the immediate right edges in this composition
-
-         -----------        -----------
-        |        #  |      |        #  |
-        |        #  |      |        #  |
-        |        #  |      |        #  |
-        |-----------|  ->  |-----------|
-        |          #|      |        #  |
-        |          #|      |        #  |
-        |          #|      |        #  |
-         -----------        -----------
+        Return True if panel bottoms for the nodes are aligned
         """
+        arr = np.array(self.bottoms)
+        return all(arr == arr[0])
 
-    def align_tops(self):
+    @property
+    def lefts_align(self) -> bool:
         """
-        Align the immediate top edges in this composition
-
-         -----------        -----------
-        |#####|     |      |     |     |
-        |     |#####|      |#####|#####|
-        |     |     |  ->  |     |     |
-        |     |     |      |     |     |
-        |     |     |      |     |     |
-         -----------        -----------
+        Return True if panel lefts for the nodes are aligned
         """
+        arr = np.array(self.lefts)
+        return all(arr == arr[0])
 
-    def align(self):
+    @property
+    def tops_align(self) -> bool:
         """
-        Align all the edges in this composition & contained compositions
-
-        This function mutates the layout spaces, specifically the
-        alignment_margins along the sides of the plot.
+        Return True if panel tops for the nodes are aligned
         """
-        self.align_lefts()
-        self.align_bottoms()
-        self.align_rights()
-        self.align_tops()
-
-        for item in self.nodes:
-            if isinstance(item, LayoutTree):
-                item.align()
-
-        with suppress(AttributeError):
-            del self.lefts
-
-        with suppress(AttributeError):
-            del self.bottoms
+        arr = np.array(self.tops)
+        return all(arr == arr[0])
 
-        with suppress(AttributeError):
-            del self.rights
-
-        with suppress(AttributeError):
-            del self.tops
+    @property
+    def rights_align(self) -> bool:
+        """
+        Return True if panel rights for the nodes are aligned
+        """
+        arr = np.array(self.rights)
+        return all(arr == arr[0])
 
     @property
     @abc.abstractmethod
@@ -288,22 +259,13 @@ class LayoutTree:
         This function mutates the composition gridspecs; specifically the
         width_ratios and height_ratios.
         """
-        self.resize_widths()
-        self.resize_heights()
 
-        for item in self.nodes:
-            if isinstance(item, LayoutTree):
-                item.resize()
-
-    def resize_widths(self):
+    def resize_sub_compositions(self):
         """
-        Resize the widths of gridspec so that panels have equal widths
-        """
-
-    def resize_heights(self):
-        """
-        Resize the heights of gridspec so that panels have equal heights
+        Resize panels in the compositions contained in this one
         """
+        for tree in self.sub_compositions:
+            tree.resize()
 
     @staticmethod
     def create(
@@ -368,6 +330,11 @@ class ColumnsTree(LayoutTree):
          -------------------
     """
 
+    def align(self):
+        self.align_tops()
+        self.align_bottoms()
+        self.align_sub_compositions()
+
     @cached_property
     def lefts(self):
         left_item = self.nodes[0]
@@ -383,14 +350,6 @@ class ColumnsTree(LayoutTree):
         else:
             left_item.set_left_alignment_margin(value)
 
-    def align_bottoms(self):
-        values = max(self.bottoms) - np.array(self.bottoms)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.b.alignment_margin = value
-            else:
-                item.set_bottom_alignment_margin(value)
-
     @cached_property
     def bottoms(self):
         values = []
@@ -401,6 +360,33 @@ class ColumnsTree(LayoutTree):
                 values.append(max(item.bottoms))
         return values
 
+    def align_bottoms(self):
+        """
+        Align the immediate bottom edges this composition
+
+         -----------        -----------
+        |     |     |      |     |     |
+        |     |     |      |     |     |
+        |     |     |  ->  |     |     |
+        |     |#####|      |#####|#####|
+        |#####|     |      |     |     |
+         -----------        -----------
+        """
+        # If panels are aligned and have a non-zero alignment_margin,
+        # aligning them again will set that value to zero and undoes
+        # the alignment.
+        if self.bottoms_align:
+            return
+
+        values = max(self.bottoms) - np.array(self.bottoms)
+        for item, value in zip(self.nodes, values):
+            if isinstance(item, LayoutSpaces):
+                item.b.alignment_margin = value
+            else:
+                item.set_bottom_alignment_margin(value)
+
+        del self.bottoms
+
     def set_bottom_alignment_margin(self, value: float):
         for item in self.nodes:
             if isinstance(item, LayoutSpaces):
@@ -423,14 +409,6 @@ class ColumnsTree(LayoutTree):
         else:
             right_item.set_right_alignment_margin(value)
 
-    def align_tops(self):
-        values = np.array(self.tops) - min(self.tops)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.t.alignment_margin = value
-            else:
-                item.set_top_alignment_margin(value)
-
     @cached_property
     def tops(self):
         values = []
@@ -441,6 +419,30 @@ class ColumnsTree(LayoutTree):
                 values.append(min(item.tops))
         return values
 
+    def align_tops(self):
+        """
+        Align the immediate top edges in this composition
+
+         -----------        -----------
+        |#####|     |      |     |     |
+        |     |#####|      |#####|#####|
+        |     |     |  ->  |     |     |
+        |     |     |      |     |     |
+        |     |     |      |     |     |
+         -----------        -----------
+        """
+        if self.tops_align:
+            return
+
+        values = np.array(self.tops) - min(self.tops)
+        for item, value in zip(self.nodes, values):
+            if isinstance(item, LayoutSpaces):
+                item.t.alignment_margin = value
+            else:
+                item.set_top_alignment_margin(value)
+
+        del self.tops
+
     def set_top_alignment_margin(self, value: float):
         for item in self.nodes:
             if isinstance(item, LayoutSpaces):
@@ -476,7 +478,10 @@ class ColumnsTree(LayoutTree):
         """
         return max(self.plot_heights)
 
-    def resize_widths(self):
+    def resize(self):
+        """
+        Resize the widths of gridspec so that panels have equal widths
+        """
         # The new width of each panel is the average width of all
         # the panels plus all the space to the left and right
         # of the panels.
@@ -486,6 +491,7 @@ class ColumnsTree(LayoutTree):
         new_plot_widths = panel_widths.mean() + non_panel_space
         width_ratios = new_plot_widths / new_plot_widths.min()
         self.gridspec.set_width_ratios(width_ratios)
+        self.resize_sub_compositions()
 
 
 @dataclass
@@ -506,13 +512,10 @@ class RowsTree(LayoutTree):
          -------------------
     """
 
-    def align_lefts(self):
-        values = max(self.lefts) - np.array(self.lefts)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.l.alignment_margin = value
-            else:
-                item.set_left_alignment_margin(value)
+    def align(self):
+        self.align_lefts()
+        self.align_rights()
+        self.align_sub_compositions()
 
     @cached_property
     def lefts(self):
@@ -524,6 +527,32 @@ class RowsTree(LayoutTree):
                 values.append(max(item.lefts))
         return values
 
+    def align_lefts(self):
+        """
+        Align the immediate left edges in this composition
+
+         -----------        -----------
+        |#          |      |  #        |
+        |#          |      |  #        |
+        |#          |      |  #        |
+        |-----------|  ->  |-----------|
+        |  #        |      |  #        |
+        |  #        |      |  #        |
+        |  #        |      |  #        |
+         -----------        -----------
+        """
+        if self.lefts_align:
+            return
+
+        values = max(self.lefts) - np.array(self.lefts)
+        for item, value in zip(self.nodes, values):
+            if isinstance(item, LayoutSpaces):
+                item.l.alignment_margin = value
+            else:
+                item.set_left_alignment_margin(value)
+
+        del self.lefts
+
     def set_left_alignment_margin(self, value: float):
         for item in self.nodes:
             if isinstance(item, LayoutSpaces):
@@ -546,14 +575,6 @@ class RowsTree(LayoutTree):
         else:
             bottom_item.set_bottom_alignment_margin(value)
 
-    def align_rights(self):
-        values = np.array(self.rights) - min(self.rights)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.r.alignment_margin = value
-            else:
-                item.set_right_alignment_margin(value)
-
     @cached_property
     def rights(self):
         values = []
@@ -564,6 +585,32 @@ class RowsTree(LayoutTree):
                 values.append(min(item.rights))
         return values
 
+    def align_rights(self):
+        """
+        Align the immediate right edges in this composition
+
+         -----------        -----------
+        |        #  |      |        #  |
+        |        #  |      |        #  |
+        |        #  |      |        #  |
+        |-----------|  ->  |-----------|
+        |          #|      |        #  |
+        |          #|      |        #  |
+        |          #|      |        #  |
+         -----------        -----------
+        """
+        if self.rights_align:
+            return
+
+        values = np.array(self.rights) - min(self.rights)
+        for item, value in zip(self.nodes, values):
+            if isinstance(item, LayoutSpaces):
+                item.r.alignment_margin = value
+            else:
+                item.set_right_alignment_margin(value)
+
+        del self.rights
+
     def set_right_alignment_margin(self, value: float):
         for item in self.nodes:
             if isinstance(item, LayoutSpaces):
@@ -614,8 +661,13 @@ class RowsTree(LayoutTree):
         """
         return sum(self.plot_heights)
 
-    def resize_heights(self):
-        # The new width of each panel is the average width of all
+    def resize(self):
+        """
+        Resize the heights of gridspec so that panels have equal heights
+
+        This method resizes (recursively) the contained compositions
+        """
+        # The new height of each panel is the average width of all
         # the panels plus all the space above and below the panels.
         plot_heights = np.array(self.plot_heights)
         panel_heights = np.array(self.panel_heights)
@@ -623,3 +675,4 @@ class RowsTree(LayoutTree):
         new_plot_heights = panel_heights.mean() + non_panel_space
         height_ratios = new_plot_heights / new_plot_heights.max()
         self.gridspec.set_height_ratios(height_ratios)
+        self.resize_sub_compositions()

plotnine/_mpl/layout_manager/_spaces.py

@@ -222,7 +222,9 @@ class left_spaces(_side_spaces):
     axis_title_y_margin_left: float = 0
     axis_title_y: float = 0
     axis_title_y_margin_right: float = 0
+    axis_text_y_margin_left: float = 0
     axis_text_y: float = 0
+    axis_text_y_margin_right: float = 0
     axis_ticks_y: float = 0
 
     def _calculate(self):
@@ -255,8 +257,13 @@ class left_spaces(_side_spaces):
             self.axis_title_y_margin_right = m.r
 
         # Account for the space consumed by the axis
-        self.axis_text_y = items.axis_text_y_max_width("first_col")
-        self.axis_ticks_y = items.axis_ticks_y_max_width("first_col")
+        self.axis_text_y = items.axis_text_y_max_width_at("first_col")
+        if self.axis_text_y:
+            m = theme.get_margin("axis_text_y").fig
+            self.axis_text_y_margin_left = m.l
+            self.axis_text_y_margin_right = m.r
+
+        self.axis_ticks_y = items.axis_ticks_y_max_width_at("first_col")
 
         # Adjust plot_margin to make room for ylabels that protude well
         # beyond the axes
@@ -576,7 +583,9 @@ class bottom_spaces(_side_spaces):
     axis_title_x_margin_bottom: float = 0
     axis_title_x: float = 0
     axis_title_x_margin_top: float = 0
+    axis_text_x_margin_bottom: float = 0
     axis_text_x: float = 0
+    axis_text_x_margin_top: float = 0
     axis_ticks_x: float = 0
 
     def _calculate(self):
@@ -616,8 +625,12 @@ class bottom_spaces(_side_spaces):
             self.axis_title_x_margin_top = m.t * F
 
         # Account for the space consumed by the axis
-        self.axis_ticks_x = items.axis_ticks_x_max_height("last_row")
-        self.axis_text_x = items.axis_text_x_max_height("last_row")
+        self.axis_text_x = items.axis_text_x_max_height_at("last_row")
+        if self.axis_text_x:
+            m = theme.get_margin("axis_text_x").fig
+            self.axis_text_x_margin_bottom = m.b
+            self.axis_text_x_margin_top = m.t
+        self.axis_ticks_x = items.axis_ticks_x_max_height_at("last_row")
 
         # Adjust plot_margin to make room for ylabels that protude well
         # beyond the axes
@@ -736,7 +749,7 @@ class LayoutSpaces:
     sw: float = field(init=False, default=0)
     """vertical spacing btn panels w.r.t figure"""
 
-    gsparams: GridSpecParams = field(init=False)
+    gsparams: GridSpecParams = field(init=False, repr=False)
     """Grid spacing btn panels w.r.t figure"""
 
     def __post_init__(self):
@@ -917,13 +930,13 @@ class LayoutSpaces:
             self.sh += self.t.strip_text_x_height_top * (1 + strip_align_x)
 
         if facet.free["x"]:
-            self.sh += self.items.axis_text_x_max_height(
+            self.sh += self.items.axis_text_x_max_height_at(
                 "all"
-            ) + self.items.axis_ticks_x_max_height("all")
+            ) + self.items.axis_ticks_x_max_height_at("all")
         if facet.free["y"]:
-            self.sw += self.items.axis_text_y_max_width(
+            self.sw += self.items.axis_text_y_max_width_at(
                 "all"
-            ) + self.items.axis_ticks_y_max_width("all")
+            ) + self.items.axis_ticks_y_max_width_at("all")
 
         # width and height of axes as fraction of figure width & height
         self.w = ((self.r.right - self.l.left) - self.sw * (ncol - 1)) / ncol

plotnine/_mpl/patches.py

@@ -49,7 +49,7 @@ class StripTextPatch(FancyBboxPatch):
             return
 
         text = self.text
-        posx, posy = text.get_transform().transform((text._x, text._y))
+        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)

plotnine/_mpl/text.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
-import typing
+from typing import TYPE_CHECKING
 
 from matplotlib.text import Text
 
 from .patches import StripTextPatch
-from .utils import bbox_in_axes_space
+from .utils import bbox_in_axes_space, rel_position
 
-if typing.TYPE_CHECKING:
+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):
@@ -23,8 +24,6 @@ class StripText(Text):
 
     def __init__(self, info: strip_draw_info):
         kwargs = {
-            "ha": info.ha,
-            "va": info.va,
             "rotation": info.rotation,
             "transform": info.ax.transAxes,
             "clip_on": False,
@@ -40,38 +39,74 @@ class StripText(Text):
         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):
+        """
+        Justify the text along the 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)
+        self.set_position((x, y))
+
+    def _justify_vertically(self, renderer):
+        """
+        Justify the text along the 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))
+
     def draw(self, renderer: RendererBase):
         if not self.get_visible():
             return
 
-        info = self.draw_info
-        # "fill up" spatch to contain the text
+        # expand strip_text patch to contain the text
         self.patch.update_position_size(renderer)
 
-        # Get bbox of spatch in transAxes space
-        patch_bbox = bbox_in_axes_space(self.patch, info.ax, renderer)
-
         # Align patch across the edge of the panel
-        if info.position == "top":
-            l, b, w, h = info.x, info.y, info.box_width, patch_bbox.height
-            b = b + patch_bbox.height * info.strip_align
+        if self.draw_info.position == "top":
+            self._justify_horizontally(renderer)
         else:  # "right"
-            l, b, w, h = info.x, info.y, patch_bbox.width, info.box_height
-            l = l + patch_bbox.width * info.strip_align
+            self._justify_vertically(renderer)
 
-        self.patch.set_bounds(l, b, w, h)
-        self.patch.set_transform(info.ax.transAxes)
+        self.patch.set_transform(self.draw_info.ax.transAxes)
         self.patch.set_mutation_scale(0)
 
         # Put text in center of patch
-        self._x = l + w / 2
-        self._y = b + h / 2
-
-        # "anchor" aligns before rotation so the right-strip get properly
-        # centered text
         self.set_rotation_mode("anchor")
-        self.set_horizontalalignment("center")  # right-strip
-        self.set_verticalalignment("center_baseline")  # top-strip
+        self.set_verticalalignment("center_baseline")
 
         # Draw spatch
         self.patch.draw(renderer)

plotnine/_utils/__init__.py

@@ -299,7 +299,7 @@ def ninteraction(df: pd.DataFrame, drop: bool = False) -> list[int]:
         return _id_var(df[df.columns[0]], drop)
 
     # Calculate individual ids
-    ids = df.apply(_id_var, axis=0)
+    ids = df.apply(_id_var, axis=0, drop=drop)
     ids = ids.reindex(columns=list(reversed(ids.columns)))
 
     # Calculate dimensions

plotnine/facets/strips.py

@@ -63,11 +63,13 @@ class strip:
         """
         theme = self.theme
         position = self.position
+
         if position == "top":
             # The x & y values are just starting locations
             # The final location is determined by the layout manager.
             y = 1
-            ha, va = "center", "bottom"
+            ha = theme.getp(("strip_text_x", "ha"), "center")
+            va = theme.getp(("strip_text_x", "va"), "bottom")
             rotation = theme.getp(("strip_text_x", "rotation"))
             box_width = 1
             box_height = 0  # Determined by the text size
@@ -88,7 +90,8 @@ class strip:
             # The x & y values are just starting locations
             # The final location is determined by the layout manager.
             x = 1
-            ha, va = "left", "center"
+            ha = theme.getp(("strip_text_y", "ha"), "left")
+            va = theme.getp(("strip_text_y", "va"), "center")
             rotation = theme.getp(("strip_text_y", "rotation"))
             box_width = 0  # Determine by the text height
             # TODO: Allow two unique paddings for either side.