plotnine 0.14.5__py3-none-any.whl → 0.15.0a2__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._x, text._y))
-        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,13 +1,17 @@
 from __future__ import annotations
 
-import typing
+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
+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
@@ -23,56 +27,174 @@ 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,
             "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)
 
-    def draw(self, renderer: RendererBase):
-        if not self.get_visible():
-            return
+        # self.set_horizontalalignment("center")
+        # self.set_verticalalignment(
+        #     "center_baseline" if info.is_oneline else "center"
+        # )
+        # self.set_rotation_mode("anchor")
+
+    # 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):
+        """
+        Set position of the text within the top strip_background
+        """
+        info = self.draw_info
+        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 _set_position_right(self, renderer):
+        """
+        Set position of the text within the bottom strip_background
+        """
         info = self.draw_info
-        # "fill up" spatch to contain the text
-        self.patch.update_position_size(renderer)
+        ha, va, ax, m = info.ha, info.va, info.ax, info.margin
 
-        # Get bbox of spatch in transAxes space
-        patch_bbox = bbox_in_axes_space(self.patch, info.ax, renderer)
+        # bboxes in axes space
+        patch_bbox = bbox_in_axes_space(self.patch, ax, renderer)
+        text_bbox = bbox_in_axes_space(self, 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
-        else:  # "right"
-            l, b, w, h = info.x, info.y, patch_bbox.width, info.box_height
-            l = l + patch_bbox.width * info.strip_align
+        # line_height in axes space
+        line_height = self._line_height(renderer) / ax.bbox.width
 
-        self.patch.set_bounds(l, b, w, h)
-        self.patch.set_transform(info.ax.transAxes)
-        self.patch.set_mutation_scale(0)
+        rel_x, rel_y = ha_as_float(ha), va_as_float(va)
 
-        # Put text in center of patch
-        self._x = l + w / 2
-        self._y = b + h / 2
+        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))
 
-        # "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
+    @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

@@ -1,18 +1,21 @@
 from __future__ import annotations
 
-import typing
+from typing import TYPE_CHECKING
 
 from matplotlib.transforms import Affine2D, Bbox
 
 from .transforms import ZEROS_BBOX
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from matplotlib.artist import Artist
     from matplotlib.axes import Axes
     from matplotlib.backend_bases import RendererBase
     from matplotlib.figure import Figure
+    from matplotlib.gridspec import SubplotSpec
     from matplotlib.transforms import Transform
 
+    from .gridspec import p9GridSpec
+
 
 def bbox_in_figure_space(
     artist: Artist, fig: Figure, renderer: RendererBase
@@ -51,28 +54,93 @@ def pts_in_figure_space(fig: Figure, pts: float) -> float:
     return fig.transFigure.inverted().transform([0, pts])[1]
 
 
-def get_transPanels(fig: Figure) -> Transform:
+def get_transPanels(fig: Figure, gs: p9GridSpec) -> Transform:
     """
     Coordinate system of the Panels (facets) area
 
     (0, 0) is the bottom-left of the bottom-left panel and
     (1, 1) is the top right of the top-right panel.
 
-    The subplot parameters must be set before calling this function.
-    i.e. fig.subplots_adjust should have been called.
+    The gridspec parameters must be set before calling this function.
+    i.e. gs.update have been called.
     """
-    # Contains the layout information from which the panel area
-    # is derived
-    params = fig.subplotpars
+    # The position of the panels area in figure coordinates
+    params = gs.get_subplot_params(fig)
 
     # Figure width & height in display coordinates
     W, H = fig.bbox.width, fig.bbox.height
 
     # 1. The panels occupy space that is smaller than the figure
     # 2. That space is contained within the figure
-    # We create a transform that represent these separable aspects
-    # (but order matters), and use to transform transFigure
+    # We create a transform that represents these separable aspects
+    # (but order matters), and use it to transform transFigure
     sx, sy = params.right - params.left, params.top - params.bottom
     dx, dy = params.left * W, params.bottom * H
     transFiguretoPanels = Affine2D().scale(sx, sy).translate(dx, dy)
     return fig.transFigure + transFiguretoPanels
+
+
+def rel_position(rel: float, length: float, low: float, high: float) -> float:
+    """
+    Relatively position an object of a given length between two position
+
+    Parameters
+    ----------
+    rel:
+        Relative position of the object between the limits.
+    length:
+        Length of the object
+    low:
+        Lower limit position
+    high:
+        Upper limit position
+    """
+    return low * (1 - rel) + (high - length) * rel
+
+
+def get_subplotspecs(axs: list[Axes]) -> list[SubplotSpec]:
+    """
+    Return the SubplotSpecs of the given axes
+
+    Parameters
+    ----------
+    axs:
+        List of axes
+
+    Notes
+    -----
+    This functions returns the innermost subplotspec and it expects
+    every axes object to have one.
+    """
+    subplotspecs: list[SubplotSpec] = []
+    for ax in axs:
+        if not (subplotspec := ax.get_subplotspec()):
+            raise ValueError("Axes has no suplotspec")
+        subplotspecs.append(subplotspec)
+    return subplotspecs
+
+
+def draw_gridspec(gs: p9GridSpec, color="black", **kwargs):
+    """
+    A debug function to draw a rectangle around the gridspec
+    """
+    draw_bbox(gs.bbox_relative, gs.figure, color, **kwargs)
+
+
+def draw_bbox(bbox, figure, color="black", **kwargs):
+    """
+    A debug function to draw a rectangle around a bounding bbox
+    """
+    from matplotlib.patches import Rectangle
+
+    figure.add_artist(
+        Rectangle(
+            xy=bbox.p0,
+            width=bbox.width,
+            height=bbox.height,
+            edgecolor=color,
+            fill="facecolor" in kwargs,
+            clip_on=False,
+            **kwargs,
+        )
+    )

plotnine/_utils/__init__.py

@@ -35,8 +35,10 @@ if TYPE_CHECKING:
         DataLike,
         FloatArray,
         FloatArrayLike,
+        HorizontalJustification,
         IntArray,
-        SidePosition,
+        Side,
+        VerticalJustification,
     )
 
     T = TypeVar("T")
@@ -299,7 +301,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
@@ -310,8 +312,8 @@ def ninteraction(df: pd.DataFrame, drop: bool = False) -> list[int]:
 
     combs = np.array(np.hstack([1, np.cumprod(ndistinct[:-1])]))
     mat = np.array(ids)
-    res = (mat - 1) @ combs.T + 1
-    res = np.array(res).flatten().tolist()
+    _res = (mat - 1) @ combs.T + 1
+    res: list[int] = np.array(_res).flatten().tolist()
 
     if drop:
         return _id_var(res, drop)
@@ -511,7 +513,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)
+        data.replace(to_replace, np.nan, inplace=True)  # pyright: ignore[reportArgumentType,reportCallIssue]
         txt = "non-finite"
     else:
         txt = "missing"
@@ -604,7 +606,7 @@ def to_rgba(
         return c
 
     if is_iterable(colors):
-        colors = cast(Sequence["ColorType"], colors)
+        colors = cast("Sequence[ColorType]", colors)
 
         if all(no_color(c) for c in colors):
             return "none"
@@ -1227,11 +1229,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 +1243,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 +1266,27 @@ 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

plotnine/_utils/dev.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
-from typing import Optional
 
-
-def get_plotnine_all(use_clipboard=True) -> Optional[str]:
+def get_plotnine_all() -> str:
     """
     Generate package level * (star) imports for plotnine
-
-    The contents of __all__ in plotnine/__init__.py
     """
     from importlib import import_module
 
@@ -28,32 +24,54 @@ def get_plotnine_all(use_clipboard=True) -> Optional[str]:
         "watermark",
     )
 
-    def get_all_from_module(name, quote=False):
+    def get_all_from_module(name):
         """
         Module level imports
         """
         qname = f"plotnine.{name}"
         m = import_module(qname)
-        fmt = ('"{}",' if quote else "{},").format
-        return "\n    ".join(fmt(x) for x in sorted(m.__all__))
 
-    _imports = "\n".join(
-        f"from .{name} import (\n    {get_all_from_module(name)}\n)"
-        for name in modules
-    )
-    _all = "\n".join(
-        [
-            "__all__ = (",
-            "\n".join(
-                f"    {get_all_from_module(name, True)}" for name in modules
-            ),
-            ")",
-        ]
-    )
-    content = f"{_imports}\n\n{_all}"
-    if use_clipboard:
-        from pandas.io import clipboard
+        return sorted(m.__all__)
+
+    imports = []
+    all_funcs = []
+
+    for name in modules:
+        funcs = get_all_from_module(name)
+        import_funcs = "\n    ".join(f"{x}," for x in funcs)
+        imports.append(f"from .{name} import (\n    {import_funcs}\n)")
+        all_funcs.extend(funcs)
+
+    all_funcs = [f'    "{x}",' for x in sorted(all_funcs)]
+
+    _imports = "\n".join(imports)
+    _all = "__all__ = (\n" + "\n".join(all_funcs) + "\n)"
+
+    return f"{_imports}\n\n{_all}"
+
+
+def get_init_py() -> str:
+    """
+    Generate plotnine/__init__.py
+    """
+
+    preamble: str = """# Do not edit this file by hand.
+#
+# Generate it using:
+#
+# $ python -c 'from plotnine._utils import dev; print(dev.get_init_py())'
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("plotnine")
+except PackageNotFoundError:
+    # package is not installed
+    pass
+finally:
+    del version
+    del PackageNotFoundError
+
+"""
 
-        clipboard.copy(content)  # pyright: ignore
-    else:
-        return content
+    return preamble + get_plotnine_all()