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

plotnine/_mpl/text.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+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, rel_position
 
@@ -11,7 +15,6 @@ 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):
@@ -28,86 +31,170 @@ class StripText(Text):
             "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)
 
-    # 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):
+        # 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):
         """
-        Justify the text along the strip_background
+        Set position of the text within the top 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)
+        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 _justify_vertically(self, renderer):
+    def _set_position_right(self, renderer):
         """
-        Justify the text along the strip_background
+        Set position of the text within the bottom 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))
+        ha, va, ax, m = info.ha, info.va, info.ax, info.margin
 
-    def draw(self, renderer: RendererBase):
-        if not self.get_visible():
-            return
+        # bboxes in axes space
+        patch_bbox = bbox_in_axes_space(self.patch, ax, renderer)
+        text_bbox = bbox_in_axes_space(self, ax, renderer)
 
-        # expand strip_text patch to contain the text
-        self.patch.update_position_size(renderer)
+        # line_height in axes space
+        line_height = self._line_height(renderer) / ax.bbox.width
 
-        # Align patch across the edge of the panel
-        if self.draw_info.position == "top":
-            self._justify_horizontally(renderer)
-        else:  # "right"
-            self._justify_vertically(renderer)
+        rel_x, rel_y = ha_as_float(ha), va_as_float(va)
 
-        self.patch.set_transform(self.draw_info.ax.transAxes)
-        self.patch.set_mutation_scale(0)
+        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))
 
-        # Put text in center of patch
-        self.set_rotation_mode("anchor")
-        self.set_verticalalignment("center_baseline")
+    @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

@@ -139,7 +139,7 @@ def draw_bbox(bbox, figure, color="black", **kwargs):
             width=bbox.width,
             height=bbox.height,
             edgecolor=color,
-            fill=False,
+            fill="facecolor" in kwargs,
             clip_on=False,
             **kwargs,
         )

plotnine/_utils/__init__.py

@@ -35,8 +35,10 @@ if TYPE_CHECKING:
         DataLike,
         FloatArray,
         FloatArrayLike,
+        HorizontalJustification,
         IntArray,
         Side,
+        VerticalJustification,
     )
 
     T = TypeVar("T")
@@ -344,6 +346,8 @@ def _id_var(x: AnyArrayLike, drop: bool = False) -> list[int]:
                 # NaNs are -1, we give them the highest code
                 nan_code = -1
                 new_nan_code = np.max(x.cat.codes) + 1
+                # TODO: We are assuming that x is of type Sequence[int|nan]
+                # is that accurate.
                 lst = [val if val != nan_code else new_nan_code for val in x]
             else:
                 lst = list(x.cat.codes + 1)
@@ -357,7 +361,7 @@ def _id_var(x: AnyArrayLike, drop: bool = False) -> list[int]:
         lst = match(x, levels)
         lst = [item + 1 for item in lst]
 
-    return lst
+    return lst  # pyright: ignore[reportReturnType]
 
 
 def join_keys(x, y, by=None):
@@ -511,7 +515,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)  # pyright: ignore[reportArgumentType,reportCallIssue]
+        data.replace(to_replace, np.nan, inplace=True)
         txt = "non-finite"
     else:
         txt = "missing"
@@ -1264,3 +1268,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/doctools.py

@@ -451,7 +451,7 @@ def document_geom(geom: type[geom]) -> type[geom]:
     table = dict_to_table(("Aesthetic", "Default value"), contents)
     aesthetics_table = AESTHETICS_TABLE_TPL.format(table=table)
     tpl = dedent(geom._aesthetics_doc).strip()
-    aesthetics_doc = tpl.format(aesthetics_table=aesthetics_table)
+    aesthetics_doc = tpl.replace("{aesthetics_table}", aesthetics_table)
     aesthetics_doc = indent(aesthetics_doc, " " * 4)
 
     # common_parameters

plotnine/facets/strips.py

@@ -67,56 +67,45 @@ class strip:
         if position == "top":
             # The x & y values are just starting locations
             # The final location is determined by the layout manager.
-            y = 1
+            bg_y = 1
             ha = theme.getp(("strip_text_x", "ha"), "center")
-            va = theme.getp(("strip_text_x", "va"), "bottom")
+            va = theme.getp(("strip_text_x", "va"), "center")
             rotation = theme.getp(("strip_text_x", "rotation"))
-            box_width = 1
-            box_height = 0  # Determined by the text size
-            # TODO: Allow two unique paddings for either side.
-            # Requires implementing an mpl.patches.boxstyle that recognises
-            # two padding values.
-            strip_text_margin = (
-                theme.getp(("strip_text_x", "margin")).to("lines").b
-            )
+            bg_height = 0  # Determined by the text size
+            margin = theme.getp(("strip_text_x", "margin")).to("lines")
             strip_align = theme.getp("strip_align_x")
 
             # x & width properties of the background slide and
             # shrink the strip horizontally.
-            x = theme.getp(("strip_text_x", "x"), 0)
-            box_width = theme.getp(("strip_background_x", "width"), 1)
+            bg_x = theme.getp(("strip_text_x", "x"), 0)
+            bg_width = theme.getp(("strip_background_x", "width"), 1)
 
         elif position == "right":
             # The x & y values are just starting locations
             # The final location is determined by the layout manager.
-            x = 1
-            ha = theme.getp(("strip_text_y", "ha"), "left")
+            bg_x = 1
+            ha = theme.getp(("strip_text_y", "ha"), "center")
             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.
-            # Requires implementing an mpl.patches.boxstyle that recognises
-            # two padding values.
-            strip_text_margin = (
-                theme.getp(("strip_text_y", "margin")).to("lines").r
-            )
+            bg_width = 0  # Determine by the text height
+            margin = theme.getp(("strip_text_y", "margin")).to("lines")
             strip_align = theme.getp("strip_align_y")
 
             # y & height properties of the background slide and
             # shrink the strip vertically.
-            y = theme.getp(("strip_text_y", "y"), 0)
-            box_height = theme.getp(("strip_background_y", "height"), 1)
+            bg_y = theme.getp(("strip_text_y", "y"), 0)
+            bg_height = theme.getp(("strip_background_y", "height"), 1)
         else:
             raise ValueError(f"Unknown position for strip text: {position!r}")
 
         return strip_draw_info(
-            x=x,
-            y=y,
+            bg_x=bg_x,
+            bg_y=bg_y,
             ha=ha,
             va=va,
-            box_width=box_width,
-            box_height=box_height,
-            strip_text_margin=strip_text_margin,
+            bg_width=bg_width,
+            bg_height=bg_height,
+            margin=margin,
             strip_align=strip_align,
             position=position,
             label=self.label_info.text(),

plotnine/geoms/annotation_logticks.py

@@ -46,9 +46,7 @@ class _geom_logticks(geom_rug):
     }
     draw_legend = staticmethod(geom_path.draw_legend)
 
-    def draw_layer(
-        self, data: pd.DataFrame, layout: Layout, coord: coord, **params: Any
-    ):
+    def draw_layer(self, data: pd.DataFrame, layout: Layout, coord: coord):
         """
         Draw ticks on every panel
         """
@@ -56,7 +54,7 @@ class _geom_logticks(geom_rug):
             ploc = pid - 1
             panel_params = layout.panel_params[ploc]
             ax = layout.axs[ploc]
-            self.draw_panel(data, panel_params, coord, ax, **params)
+            self.draw_panel(data, panel_params, coord, ax)
 
     @staticmethod
     def _check_log_scale(
@@ -184,8 +182,8 @@ class _geom_logticks(geom_rug):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
+        params = self.params
         # Any passed data is ignored, the relevant data is created
         sides = params["sides"]
         lengths = params["lengths"]
@@ -203,9 +201,8 @@ class _geom_logticks(geom_rug):
         ):
             for position, length in zip(tick_positions, lengths):
                 data = pd.DataFrame({axis: position, **_aesthetics})
-                geom.draw_group(
-                    data, panel_params, coord, ax, length=length, **params
-                )
+                params["length"] = length
+                geom.draw_group(data, panel_params, coord, ax, params)
 
         if isinstance(coord, coord_flip):
             tick_range_x = panel_params.y.range
@@ -285,4 +282,6 @@ class annotation_logticks(annotate):
             linetype=linetype,
             lengths=lengths,
             base=base,
+            inherit_aes=False,
+            show_legend=False,
         )

plotnine/geoms/annotation_stripes.py

@@ -72,6 +72,8 @@ class annotation_stripes(annotate):
             fill_range=fill_range,
             extend=extend,
             direction=direction,
+            inherit_aes=False,
+            show_legend=False,
             **kwargs,
         )
 
@@ -94,9 +96,7 @@ class _geom_stripes(geom):
     }
     draw_legend = staticmethod(geom_polygon.draw_legend)
 
-    def draw_layer(
-        self, data: pd.DataFrame, layout: Layout, coord: coord, **params: Any
-    ):
+    def draw_layer(self, data: pd.DataFrame, layout: Layout, coord: coord):
         """
         Draw stripes on every panel
         """
@@ -104,7 +104,7 @@ class _geom_stripes(geom):
             ploc = pid - 1
             panel_params = layout.panel_params[ploc]
             ax = layout.axs[ploc]
-            self.draw_group(data, panel_params, coord, ax, **params)
+            self.draw_group(data, panel_params, coord, ax, self.params)
 
     @staticmethod
     def draw_group(
@@ -112,7 +112,7 @@ class _geom_stripes(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         extend = params["extend"]
         fill_range = params["fill_range"]
@@ -193,4 +193,4 @@ class _geom_stripes(geom):
             }
         )
 
-        return geom_rect.draw_group(data, panel_params, coord, ax, **params)
+        return geom_rect.draw_group(data, panel_params, coord, ax, params)

plotnine/geoms/geom.py

@@ -171,6 +171,21 @@ class geom(ABC, metaclass=Register):
 
         return result
 
+    def setup_params(self, data: pd.DataFrame):
+        """
+        Override this method to verify and/or adjust parameters
+
+        Parameters
+        ----------
+        data :
+            Data
+
+        Returns
+        -------
+        out :
+            Parameters used by the geoms.
+        """
+
     def setup_data(self, data: pd.DataFrame) -> pd.DataFrame:
         """
         Modify the data before drawing takes place
@@ -261,9 +276,7 @@ class geom(ABC, metaclass=Register):
 
         return data
 
-    def draw_layer(
-        self, data: pd.DataFrame, layout: Layout, coord: coord, **params: Any
-    ):
+    def draw_layer(self, data: pd.DataFrame, layout: Layout, coord: coord):
         """
         Draw layer across all panels
 
@@ -289,7 +302,7 @@ class geom(ABC, metaclass=Register):
             ploc = pdata["PANEL"].iloc[0] - 1
             panel_params = layout.panel_params[ploc]
             ax = layout.axs[ploc]
-            self.draw_panel(pdata, panel_params, coord, ax, **params)
+            self.draw_panel(pdata, panel_params, coord, ax)
 
     def draw_panel(
         self,
@@ -297,7 +310,6 @@ class geom(ABC, metaclass=Register):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
         """
         Plot all groups
@@ -331,7 +343,7 @@ class geom(ABC, metaclass=Register):
         """
         for _, gdata in data.groupby("group"):
             gdata.reset_index(inplace=True, drop=True)
-            self.draw_group(gdata, panel_params, coord, ax, **params)
+            self.draw_group(gdata, panel_params, coord, ax, self.params)
 
     @staticmethod
     def draw_group(
@@ -339,7 +351,7 @@ class geom(ABC, metaclass=Register):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         """
         Plot data belonging to a group.
@@ -376,7 +388,7 @@ class geom(ABC, metaclass=Register):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         """
         Plot data belonging to a unit.

plotnine/geoms/geom_abline.py

@@ -102,7 +102,6 @@ class geom_abline(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
         """
         Plot all groups
@@ -116,4 +115,6 @@ class geom_abline(geom):
 
         for _, gdata in data.groupby("group"):
             gdata.reset_index(inplace=True)
-            geom_segment.draw_group(gdata, panel_params, coord, ax, **params)
+            geom_segment.draw_group(
+                gdata, panel_params, coord, ax, self.params
+            )

plotnine/geoms/geom_blank.py

@@ -6,8 +6,6 @@ from ..doctools import document
 from .geom import geom
 
 if typing.TYPE_CHECKING:
-    from typing import Any
-
     import pandas as pd
     from matplotlib.axes import Axes
 
@@ -39,7 +37,6 @@ class geom_blank(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
     ):
         pass
 

plotnine/geoms/geom_boxplot.py

@@ -183,7 +183,7 @@ class geom_boxplot(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         def flat(*args: pd.Series[Any]) -> npt.NDArray[Any]:
             """Flatten list-likes"""
@@ -245,11 +245,11 @@ class geom_boxplot(geom):
             outliers["shape"] = outlier_value("shape")
             outliers["size"] = outlier_value("size")
             outliers["stroke"] = outlier_value("stroke")
-            geom_point.draw_group(outliers, panel_params, coord, ax, **params)
+            geom_point.draw_group(outliers, panel_params, coord, ax, params)
 
         # plot
-        geom_segment.draw_group(whiskers, panel_params, coord, ax, **params)
-        geom_crossbar.draw_group(box, panel_params, coord, ax, **params)
+        geom_segment.draw_group(whiskers, panel_params, coord, ax, params)
+        geom_crossbar.draw_group(box, panel_params, coord, ax, params)
 
     @staticmethod
     def draw_legend(

plotnine/geoms/geom_crossbar.py

@@ -78,7 +78,7 @@ class geom_crossbar(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         y = data["y"]
         xmin = data["xmin"]
@@ -160,8 +160,8 @@ class geom_crossbar(geom):
             )
 
         copy_missing_columns(box, data)
-        geom_polygon.draw_group(box, panel_params, coord, ax, **params)
-        geom_segment.draw_group(middle, panel_params, coord, ax, **params)
+        geom_polygon.draw_group(box, panel_params, coord, ax, params)
+        geom_segment.draw_group(middle, panel_params, coord, ax, params)
 
     @staticmethod
     def draw_legend(

plotnine/geoms/geom_dotplot.py

@@ -186,7 +186,7 @@ class geom_dotplot(geom):
         panel_params: panel_view,
         coord: coord,
         ax: Axes,
-        **params: Any,
+        params: dict[str, Any],
     ):
         from matplotlib.collections import PatchCollection
         from matplotlib.patches import Ellipse