plotnine 0.15.3__py3-none-any.whl → 0.16.0a1__py3-none-any.whl

plotnine/_mpl/layout_manager/_engine.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
-from warnings import warn
 
 from matplotlib.layout_engine import LayoutEngine
 
-from ...exceptions import PlotnineWarning
-from ._layout_tree import LayoutTree
-from ._spaces import LayoutSpaces
+from ._composition_side_space import CompositionSideSpaces
+from ._plot_side_space import PlotSideSpaces
 
 if TYPE_CHECKING:
     from matplotlib.figure import Figure
@@ -18,70 +16,33 @@ if TYPE_CHECKING:
 
 class PlotnineLayoutEngine(LayoutEngine):
     """
-    Implement geometry management for plotnine plots
-
-    This layout manager automatically adjusts the location of
-    objects placed around the plot panels and the subplot
-    spacing parameters so that the plot fits cleanly within
-    the figure area.
+    Geometry management for plotnine plots
+
+    It works for both singular plots (ggplot) and compositions (Compose).
+    For plots, it adjusts the position of objects around the panels and/or
+    resizes the plot to the desired aspect-ratio. For compositions, it
+    adjusts the position of objects (the annotations of the top-level
+    composition) around the plots, and also the artists around the panels
+    in all the contained plots.
     """
 
     _adjust_compatible = True
     _colorbar_gridspec = False
 
-    def __init__(self, plot: ggplot):
-        self.plot = plot
-        self.theme = plot.theme
+    def __init__(self, item: ggplot | Compose):
+        self.item = item
 
     def execute(self, fig: Figure):
         from contextlib import nullcontext
 
-        renderer = fig._get_renderer()  # pyright: ignore[reportAttributeAccessIssue]
-
-        with getattr(renderer, "_draw_disabled", nullcontext)():
-            spaces = LayoutSpaces(self.plot)
-
-        gsparams = spaces.get_gridspec_params()
-        self.plot.facet._panels_gridspec.layout(gsparams)
-        spaces.items._adjust_positions(spaces)
-
-
-class PlotnineCompositionLayoutEngine(LayoutEngine):
-    """
-    Layout Manager for Plotnine Composition
-    """
-
-    _adjust_compatible = True
-    _colorbar_gridspec = False
-
-    def __init__(self, composition: Compose):
-        self.composition = composition
-
-    def execute(self, fig: Figure):
-        from contextlib import nullcontext
+        from plotnine import ggplot
 
+        item = self.item
         renderer = fig._get_renderer()  # pyright: ignore[reportAttributeAccessIssue]
 
-        # Caculate the space taken up by all plot artists
-        lookup_spaces: dict[ggplot, LayoutSpaces] = {}
         with getattr(renderer, "_draw_disabled", nullcontext)():
-            for ps in self.composition.plotspecs:
-                lookup_spaces[ps.plot] = LayoutSpaces(ps.plot)
-
-        # Adjust the size and placements of the plots
-        tree = LayoutTree.create(self.composition, lookup_spaces)
-        tree.harmonise()
-
-        # Set the final positions of the artists in each plot
-        for plot, spaces in lookup_spaces.items():
-            gsparams = spaces.get_gridspec_params()
-            if not gsparams.valid:
-                warn(
-                    "The layout manager failed, the figure size is too small "
-                    "to contain all the plots. Use theme() increase the "
-                    "figure size and/or reduce the size of the texts.",
-                    PlotnineWarning,
-                )
-                break
-            plot.facet._panels_gridspec.layout(gsparams)
-            spaces.items._adjust_positions(spaces)
+            if isinstance(item, ggplot):
+                item._sidespaces = PlotSideSpaces(item)
+            else:
+                item._sidespaces = CompositionSideSpaces(item)
+            item._sidespaces.arrange()

plotnine/_mpl/layout_manager/_grid.py

@@ -0,0 +1,94 @@
+from collections.abc import Iterator
+from dataclasses import InitVar, dataclass
+from typing import (
+    Generic,
+    Literal,
+    Sequence,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+
+T = TypeVar("T")
+
+
+@dataclass
+class Grid(Generic[T]):
+    nrow: InitVar[int]
+    ncol: InitVar[int]
+    items: InitVar[Sequence[T]]
+    order: InitVar[Literal["row_major", "col_major"]] = "row_major"
+    """
+    Put items into the grid left->right, top->bottom starting at `start`.
+    Unfilled cells remain None. Returns the number of items written.
+    """
+
+    def __post_init__(
+        self,
+        nrow: int,
+        ncol: int,
+        items: Sequence[T],
+        order: Literal["row_major", "col_major"],
+    ):
+        self._grid = np.empty((nrow, ncol), dtype=object)
+
+        r, c = 0, 0
+        if order == "row_major":
+            for item in items:
+                self[r, c] = item
+                c += 1
+                if c >= ncol:
+                    r, c = r + 1, 0
+        else:
+            for item in items:
+                self[r, c] = item
+                r += 1
+                if r >= nrow:
+                    r, c = 0, c + 1
+
+    @overload
+    def __getitem__(self, index: tuple[int, int]) -> T | None: ...
+
+    @overload
+    def __getitem__(self, index: tuple[int, slice]) -> list[T | None]: ...
+
+    @overload
+    def __getitem__(self, index: tuple[slice, int]) -> list[T | None]: ...
+
+    @overload
+    def __getitem__(
+        self,
+        index: tuple[slice, slice],
+    ) -> list[list[T | None]]: ...
+
+    def __getitem__(
+        self, index: tuple[int | slice, int | slice]
+    ) -> T | None | list[T | None] | list[list[T | None]]:
+        """
+        Access grid items with 2D indexing:
+        """
+        return self._grid[index]  # pyright: ignore[reportReturnType]
+
+    def __setitem__(
+        self,
+        index: tuple[int | slice, slice | int],
+        value: T | None | list[T | None] | list[list[T | None]],
+    ) -> None:
+        self._grid[index] = value
+
+    def iter_rows(self) -> Iterator[list[T | None]]:
+        """
+        Row by row
+        """
+        n = self._grid.shape[0]
+        for row in range(n):
+            yield self[row, :]
+
+    def iter_cols(self) -> Iterator[list[T | None]]:
+        """
+        Column by column
+        """
+        n = self._grid.shape[1]
+        for col in range(n):
+            yield self[:, col]