plotnine 0.14.5__py3-none-any.whl → 0.15.0.dev2__py3-none-any.whl

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/_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=False,
+            clip_on=False,
+            **kwargs,
+        )
+    )

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
@@ -310,8 +310,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 +511,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 +604,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"

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()

plotnine/animation.py

@@ -233,6 +233,6 @@ class PlotnineAnimation(ArtistAnimation):
         plot.axs = axs
         with plot_context(plot):
             plot._build()
-            plot.figure, plot.axs = plot.facet.setup(plot)
+            plot.axs = plot.facet.setup(plot)
             plot._draw_layers()
         return plot

plotnine/coords/coord_trans.py

@@ -117,7 +117,7 @@ class coord_trans(coord):
                 range=ranges.range,
             )
             sv.range = tuple(sorted(ranges.range_coord))  # type: ignore
-            breaks = cast(tuple[float, float], sv.breaks)
+            breaks = cast("tuple[float, float]", sv.breaks)
             sv.breaks = transform_value(trans, breaks)
             sv.minor_breaks = transform_value(trans, sv.minor_breaks)
             return sv

plotnine/data/__init__.py

@@ -81,20 +81,24 @@ def _process_categories():
     """
     Set columns in some of the dataframes to categoricals
     """
-    global diamonds, midwest, mpg, msleep, penguins
+    global diamonds, penguins
     diamonds = _ordered_categories(
         diamonds,
         {
-            "cut": "Fair, Good, Very Good, Premium, Ideal".split(", "),
-            "clarity": "I1 SI2 SI1 VS2 VS1 VVS2 VVS1 IF".split(),
+            "cut": ["Fair", "Good", "Very Good", "Premium", "Ideal"],
+            "clarity": [
+                "I1",
+                "SI2",
+                "SI1",
+                "VS2",
+                "VS1",
+                "VVS2",
+                "VVS1",
+                "IF",
+            ],
             "color": list("DEFGHIJ"),
         },
     )
-    mpg = _unordered_categories(
-        mpg, "manufacturer model trans fl drv class".split()
-    )
-    midwest = _unordered_categories(midwest, ["category"])
-    msleep = _unordered_categories(msleep, ["vore", "conservation"])
     penguins = _unordered_categories(penguins, ["species", "island", "sex"])
 
 

plotnine/doctools.py

@@ -188,7 +188,7 @@ def dict_to_table(header: tuple[str, str], contents: dict[str, str]) -> str:
     fill       `None`
     """
     rows = [
-        (name, value if value == "" else f"`{value!r}`" "{.py}")
+        (name, value if value == "" else f"`{value!r}`{{.py}}")
         for name, value in contents.items()
     ]
     return table_function(rows, headers=header, tablefmt="grid")

plotnine/facets/facet.py

@@ -20,9 +20,9 @@ if typing.TYPE_CHECKING:
     import numpy.typing as npt
     from matplotlib.axes import Axes
     from matplotlib.figure import Figure
-    from matplotlib.gridspec import GridSpec
 
     from plotnine import ggplot, theme
+    from plotnine._mpl.gridspec import p9GridSpec
     from plotnine.coords.coord import coord
     from plotnine.facets.labelling import CanBeStripLabellingFunc
     from plotnine.facets.layout import Layout
@@ -93,6 +93,7 @@ class facet:
 
     # Axes
     axs: list[Axes]
+    _panels_gridspec: p9GridSpec
 
     # ggplot object that the facet belongs to
     plot: ggplot
@@ -100,8 +101,6 @@ class facet:
     # Facet strips
     strips: Strips
 
-    grid_spec: GridSpec
-
     # The plot environment
     environment: Environment
 
@@ -121,6 +120,11 @@ class facet:
         self.as_table = as_table
         self.drop = drop
         self.dir = dir
+        allowed_scales = ["fixed", "free", "free_x", "free_y"]
+        if scales not in allowed_scales:
+            raise ValueError(
+                "Argument `scales` must be one of {allowed_scales}."
+            )
         self.free = {
             "x": scales in ("free_x", "free"),
             "y": scales in ("free_y", "free"),
@@ -137,17 +141,18 @@ class facet:
     def setup(self, plot: ggplot):
         self.plot = plot
         self.layout = plot.layout
+        self.figure = plot.figure
 
-        if hasattr(plot, "figure"):
-            self.figure, self.axs = plot.figure, plot.axs
+        if hasattr(plot, "axs"):
+            self.axs = plot.axs
         else:
-            self.figure, self.axs = self.make_figure()
+            self.axs = self._make_axes()
 
         self.coordinates = plot.coordinates
         self.theme = plot.theme
         self.layout.axs = self.axs
         self.strips = Strips.from_facet(self)
-        return self.figure, self.axs
+        return self.axs
 
     def setup_data(self, data: list[pd.DataFrame]) -> list[pd.DataFrame]:
         """
@@ -346,17 +351,8 @@ class facet:
         ax.xaxis.set_major_formatter(MyFixedFormatter(panel_params.x.labels))
         ax.yaxis.set_major_formatter(MyFixedFormatter(panel_params.y.labels))
 
-        pad_x = (
-            margin.get_as("t", "pt")
-            if (margin := theme.getp(("axis_text_x", "margin")))
-            else 0
-        )
-
-        pad_y = (
-            margin.get_as("r", "pt")
-            if (margin := theme.getp(("axis_text_y", "margin")))
-            else 0
-        )
+        pad_x = theme.get_margin("axis_text_x").pt.t
+        pad_y = theme.get_margin("axis_text_y").pt.r
 
         ax.tick_params(axis="x", which="major", pad=pad_x)
         ax.tick_params(axis="y", which="major", pad=pad_y)
@@ -372,7 +368,7 @@ class facet:
         new = result.__dict__
 
         # don't make a deepcopy of the figure & the axes
-        shallow = {"figure", "axs", "first_ax", "last_ax"}
+        shallow = {"axs", "first_ax", "last_ax"}
         for key, item in old.items():
             if key in shallow:
                 new[key] = item
@@ -382,35 +378,31 @@ class facet:
 
         return result
 
-    def _make_figure(self) -> tuple[Figure, GridSpec]:
+    def _get_panels_gridspec(self) -> p9GridSpec:
         """
-        Create figure & gridspec
+        Create gridspec for the panels
         """
-        import matplotlib.pyplot as plt
-        from matplotlib.gridspec import GridSpec
+        from plotnine._mpl.gridspec import p9GridSpec
 
-        return plt.figure(), GridSpec(self.nrow, self.ncol)
+        return p9GridSpec(
+            self.nrow, self.ncol, self.figure, nest_into=self.plot._gridspec[0]
+        )
 
-    def make_figure(self) -> tuple[Figure, list[Axes]]:
+    def _make_axes(self) -> list[Axes]:
         """
-        Create and return Matplotlib figure and subplot axes
+        Create and return subplot axes
         """
         num_panels = len(self.layout.layout)
         axsarr = np.empty((self.nrow, self.ncol), dtype=object)
 
-        # Create figure & gridspec
-        figure, gs = self._make_figure()
-        self.grid_spec = gs
+        self._panels_gridspec = self._get_panels_gridspec()
 
         # Create axes
         it = itertools.product(range(self.nrow), range(self.ncol))
         for i, (row, col) in enumerate(it):
-            axsarr[row, col] = figure.add_subplot(gs[i])
-
-        # axsarr = np.array([
-        #     figure.add_subplot(gs[i])
-        #     for i in range(self.nrow * self.ncol)
-        # ]).reshape((self.nrow, self.ncol))
+            axsarr[row, col] = self.figure.add_subplot(
+                self._panels_gridspec[i]
+            )
 
         # Rearrange axes
         # They are ordered to match the positions in the layout table
@@ -429,9 +421,9 @@ class facet:
 
         # Delete unused axes
         for ax in axs[num_panels:]:
-            figure.delaxes(ax)
+            self.figure.delaxes(ax)
         axs = axs[:num_panels]
-        return figure, list(axs)
+        return list(axs)
 
     def _aspect_ratio(self) -> Optional[float]:
         """
@@ -477,8 +469,7 @@ def combine_vars(
     has_all = [x.shape[1] == len(vars) for x in values]
     if not any(has_all):
         raise PlotnineError(
-            "At least one layer must contain all variables "
-            "used for facetting"
+            "At least one layer must contain all variables used for facetting"
         )
     base = pd.concat([x for i, x in enumerate(values) if has_all[i]], axis=0)
     base = base.drop_duplicates()

plotnine/facets/facet_grid.py

@@ -107,9 +107,11 @@ class facet_grid(facet):
         self.space = space
         self.margins = margins
 
-    def _make_figure(self):
-        import matplotlib.pyplot as plt
-        from matplotlib.gridspec import GridSpec
+    def _get_panels_gridspec(self):
+        """
+        Create gridspec for the panels
+        """
+        from plotnine._mpl.gridspec import p9GridSpec
 
         layout = self.layout
         space = self.space
@@ -155,7 +157,13 @@ class facet_grid(facet):
             ratios["width_ratios"] = self.space.get("x")
             ratios["height_ratios"] = self.space.get("y")
 
-        return plt.figure(), GridSpec(self.nrow, self.ncol, **ratios)
+        return p9GridSpec(
+            self.nrow,
+            self.ncol,
+            self.figure,
+            nest_into=self.plot._gridspec[0],
+            **ratios,
+        )
 
     def compute_layout(self, data: list[pd.DataFrame]) -> pd.DataFrame:
         if not self.rows and not self.cols:
@@ -302,7 +310,7 @@ def parse_grid_facets_old(
         "((var1, var2), (var3, var4))",
     ]
     error_msg_s = (
-        "Valid sequences for specifying 'facets' look like" f" {valid_seqs}"
+        f"Valid sequences for specifying 'facets' look like {valid_seqs}"
     )
 
     valid_forms = [
@@ -314,7 +322,7 @@ def parse_grid_facets_old(
         ". ~ func(var1) + func(var2)",
         ". ~ func(var1+var3) + func(var2)",
     ] + valid_seqs
-    error_msg_f = "Valid formula for 'facet_grid' look like" f" {valid_forms}"
+    error_msg_f = f"Valid formula for 'facet_grid' look like {valid_forms}"
 
     if not isinstance(facets, str):
         if len(facets) == 1: