rgrid-python 4.5.3__tar.gz → 4.5.3.post2__tar.gz

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3
+Version: 4.5.3.post2
 Summary: Python port of the R grid package (tracks R grid 4.5.3)
 Project-URL: Homepage, https://github.com/Bio-Babel/grid_py
 Project-URL: Repository, https://github.com/Bio-Babel/grid_py
@@ -41,6 +41,8 @@ Description-Content-Type: text/markdown
 
 # grid_py
 
+[![PyPI](https://img.shields.io/pypi/v/rgrid-python)](https://pypi.org/project/rgrid-python/)
+
 Python port of the R **grid** package.
 
 ## Installation

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/README.md

@@ -1,5 +1,7 @@
 # grid_py
 
+[![PyPI](https://img.shields.io/pypi/v/rgrid-python)](https://pypi.org/project/rgrid-python/)
+
 Python port of the R **grid** package.
 
 ## Installation

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/__init__.py

@@ -6,7 +6,7 @@ units, viewports, grobs (graphical objects), layouts, and rendering via
 Cairo (pycairo).
 """
 
-__version__ = "4.5.3"
+__version__ = "4.5.3.post2"
 
 # --- Utilities ---
 from grid_py._utils import depth, explode, grid_pretty, n2mfrow
@@ -18,13 +18,14 @@ from grid_py._just import valid_just, resolve_hjust, resolve_vjust, resolve_rast
 from grid_py._units import (
     Unit, is_unit, unit_type, unit_c, unit_length,
     unit_pmax, unit_pmin, unit_psum, unit_rep,
+    unit_summary_sum, unit_summary_min, unit_summary_max,
     string_width, string_height, string_ascent, string_descent,
     absolute_size,
     convert_unit, convert_x, convert_y, convert_width, convert_height,
 )
 
 # --- Graphical Parameters ---
-from grid_py._gpar import Gpar, get_gpar
+from grid_py._gpar import Gpar, get_gpar, gpar
 
 # --- Arrow ---
 from grid_py._arrow import Arrow, arrow
@@ -226,11 +227,12 @@ __all__ = [
     # Units
     "Unit", "is_unit", "unit_type", "unit_c", "unit_length",
     "unit_pmax", "unit_pmin", "unit_psum", "unit_rep",
+    "unit_summary_sum", "unit_summary_min", "unit_summary_max",
     "string_width", "string_height", "string_ascent", "string_descent",
     "absolute_size",
     "convert_unit", "convert_x", "convert_y", "convert_width", "convert_height",
     # Gpar
-    "Gpar", "get_gpar",
+    "Gpar", "gpar", "get_gpar",
     # Arrow
     "Arrow", "arrow",
     # Path

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_draw.py

@@ -109,6 +109,12 @@ def _subset_gpar(gp: Optional[Gpar], i: int) -> Optional[Gpar]:
             picked = val[i % len(val)]
         elif isinstance(val, (list, tuple)) and len(val) > 1:
             picked = val[i % len(val)]
+        elif isinstance(val, (list, tuple)) and len(val) == 1 \
+                and val[0] is None and key in ("col", "fill"):
+            # Length-1 [None] NA sentinel from Gpar(col=None)/Gpar(fill=None).
+            # Preserve the NA intent across subset — emit "transparent" so
+            # the renderer's scalar-colour path parses to (0,0,0,0).
+            picked = "transparent"
         else:
             picked = val
 
@@ -684,24 +690,44 @@ def _pop_grob_vp(vp: Any) -> None:
 def _vp_depth(vp: Any) -> int:
     """Return the depth of a viewport (number of levels it adds).
 
+    Mirrors R's ``depth()`` generic (grid R/grid.R) for every viewport
+    container: VpStack pushes ``sum(depth(child))`` levels, VpList
+    pushes ``depth(last)``, VpTree pushes ``depth(parent) + depth(last
+    child)``, plain Viewport pushes 1, VpPath pushes ``n``.
+
+    Recognised types are routed through :func:`._viewport.depth` (the
+    canonical R-faithful dispatch); this is what guarantees
+    ``_pop_grob_vp(grob.vp)`` pops the right count when a Gtable's
+    ``make_context`` returns ``VpStack(orig_vp, layout_vp)``. The
+    prior implementation only checked ``hasattr(vp, "depth")`` —
+    VpStack/VpList don't expose a method, so it fell through to
+    ``return 1`` and left every nested layout vp on the layout_stack
+    after the gtable rendered, breaking every grob drawn after.
+
+    Duck-typed objects with a ``.depth()`` method (used by tests and
+    user-defined viewport-like objects) are still honoured as a
+    fallback for unknown types.
+
     Parameters
     ----------
     vp : Any
-        A viewport, VpPath, VpStack, VpList, or VpTree.
+        A viewport, VpPath, VpStack, VpList, VpTree, or any
+        depth-bearing duck-typed object.
 
     Returns
     -------
     int
         The depth.
     """
+    from ._viewport import (
+        Viewport, VpList, VpStack, VpTree, depth as _depth,
+    )
     from ._path import VpPath
 
-    if isinstance(vp, VpPath):
-        # VpPath stores the number of path components
-        return getattr(vp, "n", 1)
+    if isinstance(vp, (Viewport, VpList, VpStack, VpTree, VpPath)):
+        return _depth(vp)
     if hasattr(vp, "depth"):
         return vp.depth()
-    # Default single viewport depth
     return 1
 
 

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_gpar.py

@@ -14,7 +14,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 import numpy as np
 
-__all__ = ["Gpar", "get_gpar"]
+__all__ = ["Gpar", "gpar", "get_gpar"]
 
 # ---------------------------------------------------------------------------
 # Constants
@@ -199,6 +199,14 @@ class Gpar:
         # -- process remaining parameters ----------------------------------
         for name, value in kwargs.items():
             if value is None:
+                # Colour parameters: preserve explicit None as a one-element
+                # NA sentinel so the renderer can tell "col absent (inherit,
+                # default black)" apart from "col explicitly NA (transparent)".
+                # Mirrors R's ``gpar(col=NA)`` / ``gpar(fill=NA)`` semantics
+                # (see R grid src/gpar.c gpCol(): isNull(col) → R_TRANWHITE).
+                # Other parameters have no NA semantic; drop silently.
+                if name in ("col", "fill"):
+                    params[name] = [None]
                 continue
 
             vals = _as_list(value)
@@ -283,8 +291,16 @@ class Gpar:
                 # backend, matching R's behaviour).
                 pass
 
-            # Store single-element lists as scalars for cleaner repr.
-            params[name] = vals[0] if len(vals) == 1 else vals
+            # Store single-element lists as scalars for cleaner repr,
+            # except for the colour NA sentinel [None] which must stay a
+            # sequence so the renderer treats it as R's gpar(col=NA).
+            if len(vals) == 1:
+                if name in ("col", "fill") and vals[0] is None:
+                    params[name] = [None]
+                else:
+                    params[name] = vals[0]
+            else:
+                params[name] = vals
 
         self._params = params
 
@@ -570,3 +586,14 @@ def get_gpar(names: Optional[Sequence[str]] = None) -> Gpar:
     gp = object.__new__(Gpar)
     gp._params = subset
     return gp
+
+
+def gpar(**kwargs: Any) -> Gpar:
+    """Factory mirroring R ``grid::gpar(...)``.
+
+    R's ``gpar`` function constructs a ``gpar`` object from arbitrary
+    keyword arguments. ``Gpar(**kwargs)`` does the same, so this is a
+    thin alias kept for direct R-to-Python translation of code that
+    reads ``gpar(col="red")``.
+    """
+    return Gpar(**kwargs)

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_layout.py

@@ -400,16 +400,23 @@ def _calc_layout_sizes(
     reduced_h = max(reduced_h, 0.0)
 
     # ---- Phase 2: allocate respected null units (layout.c:allocateRespected)
+    # R sums ALL relative widths/heights via totalWidth/totalHeight
+    # (layout.c:154-194) — not just the respected ones — when computing
+    # the aspect-ratio normalisation denominator. This is what lets a
+    # respect matrix that marks a single cell coexist with other null
+    # cells in the same dimension; restricting the sum to respected
+    # cells (the prior Python implementation) over-allocated the
+    # respected slot and collapsed everything else to 0.
     if layout._valid_respect > 0 and (reduced_w > 0 or reduced_h > 0):
         sum_w = sum(
             float(widths._values[i])
             for i in range(ncol)
-            if relative_w[i] and _col_respected(i, layout)
+            if relative_w[i]
         )
         sum_h = sum(
             float(heights._values[j])
             for j in range(nrow)
-            if relative_h[j] and _row_respected(j, layout)
+            if relative_h[j]
         )
 
         temp_w = reduced_w

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_renderer_base.py

@@ -249,9 +249,30 @@ class GridRenderer(ABC):
                 # Cell position in parent's NPC then inches
                 parent_w_dev = parent_vtr.width_cm / 2.54 * self._dev_units_per_inch
                 parent_h_dev = parent_vtr.height_cm / 2.54 * self._dev_units_per_inch
-                cell_x_in = cell_x0_dev / self._dev_units_per_inch
-                # Device y is top-down; convert to bottom-up inches
-                cell_y_in = parent_h_in - (cell_y0_dev + cell_h_dev) / self._dev_units_per_inch
+
+                # Apply layout-level hjust / vjust (R: layout.c::subRegion
+                # lines 447-450). When the cells' total dimensions don't
+                # fill the parent vp (common for chrome-merge slices in
+                # patchwork), the leftover space is distributed per the
+                # layout's justification (default 0.5 → centred). The
+                # prior implementation always pinned cells to top-left
+                # (vjust=1, hjust=0), which placed merged chrome at the
+                # top of the parent panel cell rather than just outside
+                # it, breaking simplify_fixed renders.
+                hjust = float(grid.get("hjust", 0.0))
+                vjust = float(grid.get("vjust", 1.0))
+                total_w_dev = sum(col_widths)
+                total_h_dev = sum(row_heights)
+                hjust_offset_dev = hjust * (parent_w_dev - total_w_dev)
+                vjust_offset_dev = (1.0 - vjust) * (parent_h_dev - total_h_dev)
+
+                cell_x_in = (cell_x0_dev + hjust_offset_dev) / self._dev_units_per_inch
+                # Device y is top-down; convert to bottom-up inches.
+                # vjust_offset_dev shifts the block downward in device-y
+                # (i.e. upward in bottom-up coords) by the leftover * (1-vjust).
+                cell_y_in = parent_h_in - (
+                    cell_y0_dev + cell_h_dev + vjust_offset_dev
+                ) / self._dev_units_per_inch
 
                 # Build a simple translation transform for the cell
                 from ._vp_calc import translation, multiply
@@ -280,9 +301,12 @@ class GridRenderer(ABC):
                 if layout is not None:
                     w_dev = cell_w_dev
                     h_dev = cell_h_dev
-                    respect = getattr(layout, "respect", False)
-                    grid_info = self._compute_grid(
-                        layout, w_dev, h_dev, respect=bool(respect))
+                    # R: ``calcViewportLayout`` (layout.c:492-590) reads
+                    # ``layoutRespect(layout)`` / ``layoutRespectMat(layout)``
+                    # straight off the layout object — there is no caller-side
+                    # respect argument. Mirror that: ``_calc_layout_sizes``
+                    # consumes ``layout._valid_respect`` directly.
+                    grid_info = self._compute_grid(layout, w_dev, h_dev)
                     self._layout_stack.append(grid_info)
                     self._layout_depth_stack.append(
                         len(self._vp_transform_stack))
@@ -294,8 +318,9 @@ class GridRenderer(ABC):
             # Compute grid in device units for layout children.
             w_dev = parent_vtr.width_cm / 2.54 * self._dev_units_per_inch
             h_dev = parent_vtr.height_cm / 2.54 * self._dev_units_per_inch
-            respect = getattr(layout, "respect", False)
-            grid_info = self._compute_grid(layout, w_dev, h_dev, respect=bool(respect))
+            # See R layout.c:492-590 — respect lives on the layout object;
+            # callers don't pass it down.
+            grid_info = self._compute_grid(layout, w_dev, h_dev)
 
             # The layout viewport itself has the same transform as parent
             # but we create a new VTR with the vp's xscale/yscale
@@ -388,9 +413,15 @@ class GridRenderer(ABC):
 
     def _compute_grid(
         self, layout: Any, parent_w: float, parent_h: float,
-        respect: bool = False,
     ) -> dict:
-        """Compute row/column positions for a GridLayout within the parent."""
+        """Compute row/column positions for a GridLayout within the parent.
+
+        R reference: ``layout.c:calcViewportLayout`` (lines 492-590).
+        Respect (full or matrix-form) lives on the layout object itself —
+        ``_calc_layout_sizes`` reads ``layout._valid_respect`` directly,
+        so this signature has no ``respect`` argument (matches R, where
+        there is no caller-side respect parameter either).
+        """
         from ._layout import _calc_layout_sizes, GridLayout
 
         if isinstance(layout, GridLayout):
@@ -412,9 +443,24 @@ class GridRenderer(ABC):
         col_starts = [sum(col_widths[:i]) for i in range(ncol)]
         row_starts = [sum(row_heights[:i]) for i in range(nrow)]
 
+        # Layout justification (R: layout.c::subRegion lines 433-450).
+        # When the cells' total size is less than the parent vp, hjust /
+        # vjust shift the layout block within the parent (default 0.5 →
+        # centred). ``GridLayout`` carries this on ``_valid_just`` as
+        # (hjust, vjust); fall back to (0, 1) for non-GridLayout
+        # containers (matching the prior top-left alignment).
+        valid_just = getattr(layout, "_valid_just", None)
+        if valid_just is not None:
+            hjust = float(valid_just[0])
+            vjust = float(valid_just[1])
+        else:
+            hjust, vjust = 0.0, 1.0
+
         return {
             "col_starts": col_starts, "col_widths": col_widths,
             "row_starts": row_starts, "row_heights": row_heights,
+            "parent_w": parent_w, "parent_h": parent_h,
+            "hjust": hjust, "vjust": vjust,
         }
 
     def _resolve_sizes(self, unit_obj: Any, n: int, total: float,
@@ -492,6 +538,28 @@ class GridRenderer(ABC):
     # evaluateGrobUnit -- port of R unit.c:325-590                          #
     # ===================================================================== #
 
+    # Per-renderer cycle guard — populated with id(grob) for every grob
+    # currently being measured. ``_evaluate_grob_unit`` consults this
+    # before pushing the grob's vp; re-entry for the same grob means
+    # the vp itself references its own grob*Details (e.g.
+    # ``viewport(width = grobWidth(self))``), which would otherwise
+    # infinite-recurse through calcViewportTransform → grob_metric_fn
+    # → _evaluate_grob_unit → push vp → ...
+    #
+    # R bounds the same recursion implicitly because its
+    # widthDetails.gtable returns an absolute mm sum, and R's
+    # setviewport/calcViewportTransform doesn't re-trigger the metric
+    # path during the recursive pushViewport (verified empirically:
+    # preDraw.gtable runs exactly 3 times for one toplevel grid.draw —
+    # not unbounded). We mirror the bound explicitly.
+    @property
+    def _measuring_grobs(self) -> set:
+        s = getattr(self, "_measuring_grobs_set", None)
+        if s is None:
+            s = set()
+            self._measuring_grobs_set = s
+        return s
+
     def _evaluate_grob_unit(
         self,
         grob: Any,
@@ -545,6 +613,46 @@ class GridRenderer(ABC):
         if not isinstance(grob, Grob):
             return 0.0
 
+        # --- Cycle break for self-referential grobwidth/grobheight ---
+        # When we're already measuring this grob and the grob's vp
+        # references its own width/height (e.g. patchwork's
+        # ``as_patch.GT`` builds ``viewport(width=grobWidth(grob))``),
+        # the recursive vp push would trigger _evaluate_grob_unit for
+        # the same grob again, etc. Resolve widthDetails/heightDetails
+        # directly without the recursive push — for non-context-
+        # dependent grobs (gtable widthDetails returns absolute_size of
+        # the widths sum) this gives the same answer as the full path,
+        # matching R's behaviour where preDraw.gtable runs a bounded
+        # number of times rather than unboundedly.
+        if id(grob) in self._measuring_grobs:
+            if unit_type == "grobwidth":
+                ru = width_details(grob)
+                axis = "x"
+            elif unit_type == "grobheight":
+                ru = height_details(grob)
+                axis = "y"
+            elif unit_type == "grobascent":
+                ru = ascent_details(grob)
+                axis = "y"
+            elif unit_type == "grobdescent":
+                ru = descent_details(grob)
+                axis = "y"
+            else:
+                return 0.0
+            if ru is None:
+                return 0.0
+            from ._units import Unit as _U
+            if not isinstance(ru, _U):
+                return 0.0
+            if len(ru) == 1 and ru._units[0] == "null":
+                return 0.0
+            return float(self._resolve_to_inches(ru, axis, True))
+
+        # Capture id BEFORE make_context() rebinds ``grob`` to the
+        # context-wrapped copy — we need to release the same id we added.
+        _measuring_id = id(grob)
+        self._measuring_grobs.add(_measuring_id)
+
         # --- Save state (R unit.c:355-377) ---
         saved_dl_on = state._dl_on
         state.set_display_list_on(False)
@@ -620,6 +728,7 @@ class GridRenderer(ABC):
             state.replace_gpar(saved_gpar)
             state._current_grob = saved_current_grob
             state.set_display_list_on(saved_dl_on)
+            self._measuring_grobs.discard(_measuring_id)
 
         return result
 

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_size.py

@@ -232,13 +232,36 @@ def _resolve_grob_gp(grob: Any) -> "Optional[Gpar]":
 def _text_bbox(grob: Any) -> tuple:
     """Compute (width, height) of the text bounding box in inches.
 
-    Mirrors what R's ``heightDetails.text`` / ``widthDetails.text`` return
-    (empirically verified against R 4.4 ``cairo_png`` at 150 dpi):
-
-      width  = max(per-line ink widths)           — R's ``GEStrWidth``
-      height = ink_height(first line)
+    Ports R's ``heightDetails.text`` / ``widthDetails.text`` (grid's
+    ``primitives.R:1430-1452``) — R's ``grobHeight`` on a text grob
+    returns the **ascent only** (glyph extent above baseline), never
+    the descent. ``grobDescent`` is a separate method (see
+    ``descentDetails.text``) and is exposed independently so that
+    callers can add it when needed. ggplot2's ``titleGrob``
+    (margins.R:115-132) relies on this convention — it uses
+    ``unit(1, "grobheight", grob) + y_descent`` to assemble the final
+    height — so any deviation here double-counts the descent.
+
+    Empirical verification (R 4.4 ``cairo_png`` at 150 dpi, default
+    Helvetica, fontsize 13.2 pt):
+
+      grobHeight(textGrob("A long title", fs=13.2))         = 3.293 mm
+      grobHeight(textGrob("gjpqy",        fs=13.2))         = 3.293 mm
+      grobHeight(textGrob("y",            fs=13.2))         = 3.293 mm
+
+    — i.e. the value is a font-level constant, independent of the
+    label content. Our cairo-backed ``calc_string_metric`` returns a
+    per-label ascent that varies slightly with glyph mix, which is the
+    closest we can get without implementing a full AFM font-metric
+    path; residual ≤ 0.3 mm discrepancy is a font-file difference
+    (AFM Helvetica vs. cairo's "Sans" fallback) and outside the
+    scope of this bbox function.
+
+    Height formula (port of R's ``GEStrHeight``):
+
+      width  = max(per-line ink widths)
+      height = ascent(first line)
                + (n - 1) × cex × lineheight × fontsize × 1.2 / 72
-                                                    — R's ``GEStrHeight``
 
     The per-extra-line gap ``1.2 × fontsize / 72`` is R's device-level
     ``cra[1] × ipr[1] / default_ps`` collapsed for the standard cairo /
@@ -287,11 +310,14 @@ def _text_bbox(grob: Any) -> tuple:
         n_lines = len(lines)
         # Width: max per-line width (R's ``GEStrWidth`` walks each line).
         w = max(calc_string_metric(ln, gp=gp)["width"] for ln in lines)
-        # Height: ink of first line + gap × (n - 1).  R uses the first
-        # line's ink bounds (``ascent + descent``) and extends by per-line
-        # gaps for additional lines.
+        # Height: ascent of the first line + per-line gap × (n - 1).
+        # R's ``heightDetails.text`` / ``GEStrHeight`` returns ASCENT
+        # only — never descent. Descent is a separate method
+        # (``descentDetails.text``). Including descent here would
+        # double-count it downstream in ggplot2 ``titleGrob``, which
+        # adds ``grobDescent`` manually to form the rendered height.
         m0 = calc_string_metric(lines[0], gp=gp)
-        h = m0["ascent"] + m0["descent"] + (n_lines - 1) * inter_line_gap
+        h = m0["ascent"] + (n_lines - 1) * inter_line_gap
 
         if rot == 0.0:
             # No rotation: bbox is just the text extent

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_state.py

@@ -224,6 +224,12 @@ class GridState:
         # GSS_GROUPS: group registry for define/use (R grid.h:63, state.c:51)
         # Maps group name → dict with keys: ref, xy, xyin, wh, r, etc.
         self._groups: Dict[str, Any] = {}
+        # Per-push counter of redundant self-pushes (the same vp pushed
+        # again while already current). Each genuine push appends a 0;
+        # a redundant push increments the top entry; pops decrement
+        # before actually unwinding. Prevents the cyclic parent chain
+        # that would otherwise hang ``current_vp_path``.
+        self._redundant_push_count: List[int] = [0]
 
     # ---- reset ------------------------------------------------------------
 
@@ -244,7 +250,27 @@ class GridState:
         vp : Any
             A viewport-like object.  Must expose ``name``, ``parent``,
             and ``children`` attributes (or dict keys).
+
+        Notes
+        -----
+        Pushing the same viewport object twice (e.g. when a Gtable's
+        ``make_context`` builds ``VpStack(orig_vp, layout_vp)`` and
+        the iterating push hits ``orig_vp`` while ``orig_vp`` is
+        already the current vp — happens in ``_evaluate_grob_unit``'s
+        preDraw for self-referential ``viewport(width = grobWidth(self))``
+        setups) would otherwise set ``vp.parent = vp`` and produce a
+        cyclic parent chain that deadlocks ``current_vp_path``. The
+        Python port stores parent on the vp object itself (rather than
+        on a separate per-push record like R's grid does), so we
+        track redundant self-pushes on a counter stack and treat the
+        matching ``up_viewport`` / ``pop_viewport`` as no-ops so depth
+        stays balanced.
         """
+        if vp is self._current_vp:
+            self._redundant_push_count[-1] = (
+                self._redundant_push_count[-1] + 1
+            )
+            return
         _vp_set_attr(vp, "parent", self._current_vp)
         children = _vp_children(self._current_vp)
         if children is None:
@@ -252,6 +278,7 @@ class GridState:
             _vp_set_attr(self._current_vp, "children", children)
         children.append(vp)
         self._current_vp = vp
+        self._redundant_push_count.append(0)
 
     def pop_viewport(self, n: int = 1) -> None:
         """Pop *n* viewports, navigating back toward the root.
@@ -272,8 +299,14 @@ class GridState:
         if n == 0:
             # Pop to root.
             self._current_vp = self._vp_tree
+            self._redundant_push_count = [0]
             return
         for _ in range(n):
+            # First absorb any redundant self-pushes recorded for the
+            # current vp (see ``push_viewport`` notes).
+            if self._redundant_push_count and self._redundant_push_count[-1] > 0:
+                self._redundant_push_count[-1] -= 1
+                continue
             parent = _vp_parent(self._current_vp)
             if parent is None:
                 raise ValueError(
@@ -286,6 +319,8 @@ class GridState:
             except ValueError:
                 pass
             self._current_vp = parent
+            if len(self._redundant_push_count) > 1:
+                self._redundant_push_count.pop()
 
     def up_viewport(self, n: int = 1) -> None:
         """Navigate up *n* levels without removing viewports from the tree.
@@ -305,14 +340,21 @@ class GridState:
             raise ValueError(f"'n' must be non-negative, got {n}")
         if n == 0:
             self._current_vp = self._vp_tree
+            self._redundant_push_count = [0]
             return
         for _ in range(n):
+            # Absorb redundant self-pushes first.
+            if self._redundant_push_count and self._redundant_push_count[-1] > 0:
+                self._redundant_push_count[-1] -= 1
+                continue
             parent = _vp_parent(self._current_vp)
             if parent is None:
                 raise ValueError(
                     "Cannot navigate above the root viewport."
                 )
             self._current_vp = parent
+            if len(self._redundant_push_count) > 1:
+                self._redundant_push_count.pop()
 
     def down_viewport(self, name: str, strict: bool = False) -> int:
         """Navigate down to a named viewport (breadth-first search).

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/_units.py

@@ -301,7 +301,20 @@ def _try_resolve_with_renderer(
     state = get_state()
     renderer = state.get_renderer()
 
-    if renderer is None or not hasattr(renderer, "_resolve_to_inches_idx"):
+    if renderer is None:
+        # R parity: `convertUnit` (unit.R:59-75) dispatches to `L_convert` in
+        # src/unit.c, which resolves context via `GEcurrentDevice()`. When no
+        # device is open, R's graphics system auto-opens its default device
+        # (PDF, 7×7 in) and converts against it. We replicate that here by
+        # lazily installing a default 7×7 in CairoRenderer the first time a
+        # context-dependent conversion is requested — matching R's observed
+        # behaviour: `convertHeight(unit(0.3,"npc"),"mm") == 53.34` (=0.3×7in
+        # in mm) without any prior `grid_newpage()` / `pdf()` call.
+        from .renderer import CairoRenderer
+        renderer = CairoRenderer(width=7.0, height=7.0)
+        state.init_device(renderer)
+
+    if not hasattr(renderer, "_resolve_to_inches_idx"):
         return None
 
     # Build a single-element Unit for the source
@@ -1574,6 +1587,56 @@ def convert_unit(
             )
             if resolved is not None:
                 result_vals[i] = resolved
+            elif src_unit in ("sum", "min", "max"):
+                # R ``grid/src/unit.c: L_convert`` dispatches ``sum.unit`` /
+                # ``min.unit`` / ``max.unit`` via ``L_sumUnits`` /
+                # ``L_minUnits`` / ``L_maxUnits``, each of which calls
+                # ``convertUnit`` recursively on every child in the
+                # compound's list and combines the resulting absolute
+                # lengths. Without this branch the fallback at the end of
+                # this loop returns the outer scalar (1.0) unchanged —
+                # which is why ``convertWidth(unit(1,'grobwidth',g) +
+                # unit(0.05,'inches'),'cm')`` returned 1.0 regardless of
+                # the text's actual rendered width.
+                child = x._data[i]
+                if (
+                    child is not None
+                    and isinstance(child, Unit)
+                    and len(child) > 0
+                ):
+                    child_inches: List[float] = []
+                    for j in range(len(child)):
+                        sub = Unit.__new__(Unit)
+                        sub._values = np.array(
+                            [child._values[j]], dtype=np.float64,
+                        )
+                        sub._units = [child._units[j]]
+                        sub._data = [child._data[j]]
+                        sub._is_absolute = (
+                            child._units[j] in _ABSOLUTE_UNIT_TYPES
+                        )
+                        inches_arr = convert_unit(
+                            sub, "inches",
+                            axisFrom=axisFrom, typeFrom=typeFrom,
+                            axisTo=axisTo, typeTo=typeTo,
+                            valueOnly=True,
+                        )
+                        child_inches.append(float(inches_arr[0]))
+                    if src_unit == "sum":
+                        combined = float(np.sum(child_inches))
+                    elif src_unit == "min":
+                        combined = float(np.min(child_inches))
+                    else:
+                        combined = float(np.max(child_inches))
+                    combined *= float(x._values[i])
+                    if target in _ABSOLUTE_UNIT_TYPES:
+                        result_vals[i] = combined / _INCHES_PER[target]
+                    else:
+                        result_vals[i] = combined
+                        converted = False
+                else:
+                    result_vals[i] = x._values[i]
+                    converted = False
             elif src_unit in _STR_METRIC_TYPES:
                 # Fallback without renderer: string metric → inches → target
                 inches_val = _eval_str_metric(src_unit, x._data[i], x._values[i])
@@ -1583,18 +1646,34 @@ def convert_unit(
                     result_vals[i] = inches_val
                     converted = False
             elif src_unit in _GROB_METRIC_TYPES:
-                # Fallback: grob metric → inches → target
+                # Fallback: grob metric → inches → target.
+                # Mirrors R ``grid/src/unit.c``:
+                #   evaluateGrobUnit(..., evalType=2)
+                #     unitx <- widthDetails(grob)
+                #     result = transformWidthtoINCHES(unitx, 0, ...)
+                # R takes *only index 0* of ``widthDetails``'s return,
+                # relying on its methods (e.g. ``widthDetails.titleGrob``
+                # ``<- sum(x$widths)``) to wrap multi-element units as
+                # a single sum.unit. The recursive ``transformWidthtoINCHES``
+                # then unwraps L_SUM via the compound branch above.
                 metric_unit = _eval_grob_metric(src_unit, x._data[i])
-                if (
-                    metric_unit is not None
-                    and len(metric_unit) > 0
-                    and metric_unit._units[0] in _ABSOLUTE_UNIT_TYPES
-                ):
-                    src_inches = (
-                        metric_unit._values[0]
-                        * _INCHES_PER[metric_unit._units[0]]
+                if metric_unit is not None and len(metric_unit) > 0:
+                    head = Unit.__new__(Unit)
+                    head._values = np.array(
+                        [metric_unit._values[0]], dtype=np.float64,
+                    )
+                    head._units = [metric_unit._units[0]]
+                    head._data = [metric_unit._data[0]]
+                    head._is_absolute = (
+                        metric_unit._units[0] in _ABSOLUTE_UNIT_TYPES
+                    )
+                    inches_arr = convert_unit(
+                        head, "inches",
+                        axisFrom=axisFrom, typeFrom=typeFrom,
+                        axisTo=axisTo, typeTo=typeTo,
+                        valueOnly=True,
                     )
-                    src_inches *= x._values[i]
+                    src_inches = float(inches_arr[0]) * float(x._values[i])
                     if target in _ABSOLUTE_UNIT_TYPES:
                         result_vals[i] = src_inches / _INCHES_PER[target]
                     else:

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/grid_py/renderer.py

@@ -336,12 +336,14 @@ class CairoRenderer(GridRenderer):
 
         col = gp.get("col", None)
         # R semantics:
-        #   * col=NULL (unset)      → inherit parent, default "black"
-        #   * col=NA (explicit)     → no stroke (transparent)
-        # In Python Gpar, None-scalar is dropped at construction, so
-        # ``gp.get("col") is None`` ≡ NULL.  A sequence whose entries
-        # are None (coming from ggplot2 ``colour=NA`` data) must be
-        # treated as NA, matching R's ``gpar(col=NA)``.
+        #   * col absent from gp          → inherit parent, default "black"
+        #   * Gpar(col=None)              → stored as [None] (NA sentinel)
+        #                                    → transparent (≡ R gpar(col=NA))
+        #   * sequence with first=None    → transparent (ggplot2 colour=NA)
+        #   * scalar string "NA"/"none"/  → transparent (resolved by
+        #     "transparent"                  _parse_colour)
+        # The [None] sentinel is produced by Gpar(col=None) — see
+        # _gpar.py Gpar.__init__.
         _is_seq = hasattr(col, "__len__") and not isinstance(col, str)
         if _is_seq:
             col_val = col[0]

{rgrid_python-4.5.3 → rgrid_python-4.5.3.post2}/pyproject.toml

@@ -12,7 +12,7 @@ name = "rgrid-python"
 # a corresponding R update, bump a PEP 440 post-release suffix:
 #   "4.5.3"  → "4.5.3.post1"  → "4.5.3.post2"  → ...
 # When R grid itself ships a new upstream version, move to e.g. "4.5.4".
-version = "4.5.3"
+version = "4.5.3.post2"
 description = "Python port of the R grid package (tracks R grid 4.5.3)"
 readme = "README.md"
 requires-python = ">=3.10"