rgrid-python 4.5.3.post1__py3-none-any.whl → 4.5.3.post3__py3-none-any.whl

grid_py/__init__.py

@@ -6,7 +6,7 @@ units, viewports, grobs (graphical objects), layouts, and rendering via
 Cairo (pycairo).
 """
 
-__version__ = "4.5.3.post1"
+__version__ = "4.5.3.post3"
 
 # --- Utilities ---
 from grid_py._utils import depth, explode, grid_pretty, n2mfrow
@@ -25,7 +25,7 @@ from grid_py._units import (
 )
 
 # --- 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
@@ -232,7 +232,7 @@ __all__ = [
     "absolute_size",
     "convert_unit", "convert_x", "convert_y", "convert_width", "convert_height",
     # Gpar
-    "Gpar", "get_gpar",
+    "Gpar", "gpar", "get_gpar",
     # Arrow
     "Arrow", "arrow",
     # Path

grid_py/_curve.py

@@ -1383,6 +1383,8 @@ def grid_curve(
 def xspline_grob(
     x: Optional[Any] = None,
     y: Optional[Any] = None,
+    id: Optional[Any] = None,
+    id_lengths: Optional[Any] = None,
     default_units: str = "npc",
     shape: Union[float, Sequence[float]] = 0.0,
     open_: bool = True,
@@ -1402,6 +1404,15 @@ def xspline_grob(
     x, y : Unit, numeric, sequence, or None
         Control-point coordinates.  Defaults to ``Unit([0, 1], "npc")``
         when ``None``.
+    id : array-like of int or None
+        Group label for each control point.  Points sharing an ``id`` are
+        rendered as one X-spline; the grob therefore renders one spline
+        per unique ``id`` value.  Mirrors R ``xsplineGrob(id=...)``.
+        Mutually meaningful with ``id_lengths``: pass at most one.
+    id_lengths : array-like of int or None
+        Run-length encoding of ``id``: the n-th entry is the number of
+        consecutive control points belonging to spline n.  Mirrors R's
+        ``xsplineGrob(id.lengths=...)``.
     default_units : str
         Unit type for bare numerics.
     shape : float or sequence of float
@@ -1439,9 +1450,16 @@ def xspline_grob(
     if np.any((shape_arr < -1) | (shape_arr > 1)):
         raise ValueError("all 'shape' values must be between -1 and 1")
 
+    id_arr = None if id is None else np.asarray(id, dtype=np.int64)
+    id_lengths_arr = (
+        None if id_lengths is None else np.asarray(id_lengths, dtype=np.int64)
+    )
+
     return Grob(
         x=x,
         y=y,
+        id=id_arr,
+        id_lengths=id_lengths_arr,
         shape=shape_arr,
         open_=bool(open_),
         arrow=arrow,
@@ -1456,6 +1474,8 @@ def xspline_grob(
 def grid_xspline(
     x: Optional[Any] = None,
     y: Optional[Any] = None,
+    id: Optional[Any] = None,
+    id_lengths: Optional[Any] = None,
     default_units: str = "npc",
     shape: Union[float, Sequence[float]] = 0.0,
     open_: bool = True,
@@ -1497,7 +1517,8 @@ def grid_xspline(
         The xspline grob.
     """
     grob = xspline_grob(
-        x=x, y=y, default_units=default_units,
+        x=x, y=y, id=id, id_lengths=id_lengths,
+        default_units=default_units,
         shape=shape, open_=open_, arrow=arrow,
         repEnds=repEnds, name=name, gp=gp, vp=vp,
     )

grid_py/_draw.py

@@ -412,7 +412,15 @@ def _render_grob(
             xs, ys = _calc_xspline_points(
                 x, y, shape=shape_arr, open_=open_, repEnds=rep_ends,
             )
-            renderer.draw_polyline(xs, ys, id_=None, gp=gp)
+            # R's ``xsplineGrob(open=FALSE)`` is a *filled closed* shape, not
+            # a stroked path; route through ``draw_polygon`` so ``gp$fill``
+            # actually paints (R/grid: drawDetails.xspline → C_xspline,
+            # filled when ``open == FALSE``).  ``open=TRUE`` stays a stroked
+            # polyline.
+            if open_:
+                renderer.draw_polyline(xs, ys, id_=None, gp=gp)
+            else:
+                renderer.draw_polygon(xs, ys, gp=gp)
             if arr is not None and len(xs) >= 2:
                 _draw_arrow_heads(xs, ys, arr, renderer, gp)
         else:
@@ -436,12 +444,24 @@ def _render_grob(
                 out_id += 1
                 per_group.append((xs_g, ys_g))
             if all_xs:
-                renderer.draw_polyline(
-                    np.asarray(all_xs, dtype=float),
-                    np.asarray(all_ys, dtype=float),
-                    id_=np.asarray(all_ids, dtype=int),
-                    gp=gp,
-                )
+                # Multi-id closed splines render as N separate filled
+                # subpolygons (R: xsplineGrob(id=..., open=FALSE)); use
+                # ``draw_path`` with the path_id array.  Open splines stay
+                # multi-stroke polylines.
+                if open_:
+                    renderer.draw_polyline(
+                        np.asarray(all_xs, dtype=float),
+                        np.asarray(all_ys, dtype=float),
+                        id_=np.asarray(all_ids, dtype=int),
+                        gp=gp,
+                    )
+                else:
+                    renderer.draw_path(
+                        np.asarray(all_xs, dtype=float),
+                        np.asarray(all_ys, dtype=float),
+                        path_id=np.asarray(all_ids, dtype=int),
+                        gp=gp,
+                    )
                 if arr is not None:
                     for xs_g, ys_g in per_group:
                         if len(xs_g) >= 2:
@@ -564,15 +584,18 @@ def _render_grob(
         if image is None:
             image = getattr(grob, "image", None)
         if image is not None:
-            # Apply justification (same as rect_grob)
             hj, vj = _resolve_just(grob)
             raw_x = renderer.resolve_x(getattr(grob, "x", 0.0), gp=gp)
             raw_y = renderer.resolve_y(getattr(grob, "y", 0.0), gp=gp)
             raw_w = renderer.resolve_w(getattr(grob, "width", 1.0), gp=gp)
             raw_h = renderer.resolve_h(getattr(grob, "height", 1.0), gp=gp)
-            # Compute bottom-left corner from anchor + justification
+            # `renderer.draw_raster` expects the *top-left* corner in y-down
+            # device pixels. `resolve_y` already returns y-down coords, so the
+            # y component of justification must be flipped relative to R's
+            # `justifyY(y, h, vjust) = y - h*vjust` (which assumes y-up NPC).
+            # Same correction `draw_rect` applies (renderer.py:815).
             x0 = raw_x - raw_w * hj
-            y0 = raw_y - raw_h * vj
+            y0 = raw_y - raw_h * (1.0 - vj)
             renderer.draw_raster(
                 image=image,
                 x=x0,
@@ -690,24 +713,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
 
 

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
@@ -586,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)

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

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,14 +413,27 @@ 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):
+            # Use device-units-per-inch (= dpi for raster ImageSurface, 72 for
+            # vector PDF/SVG/PS surfaces) so that absolute units (cm/mm/in/pt
+            # …) get converted to the SAME unit as ``parent_w``/``parent_h``.
+            # Passing ``self.dpi`` blindly would, for vector surfaces, scale
+            # absolute widths by dpi while the parent is measured in points,
+            # over-allocating fixed cells by ``dpi/72`` and shrinking the
+            # null-unit panel by the same factor.
             col_widths, row_heights = _calc_layout_sizes(
-                layout, parent_w, parent_h, self.dpi,
+                layout, parent_w, parent_h, self._dev_units_per_inch,
             )
         else:
             nrow = getattr(layout, "nrow", 1)
@@ -412,9 +450,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 +545,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 +620,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 +735,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
 

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

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

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

grid_py/renderer.py

@@ -141,6 +141,17 @@ class CairoRenderer(GridRenderer):
             if filename is None:
                 raise ValueError("filename is required for SVG surface")
             self._surface = cairo.SVGSurface(filename, width_pt, height_pt)
+            # Cairo's SVGSurface measures user-space in points; emit explicit
+            # ``pt`` units in the resulting <svg width="...pt" height="...pt">
+            # so SVG renderers (browsers, cairosvg, Inkscape) interpret the
+            # canvas at the intended physical size instead of treating the
+            # raw numbers as user-units (= pixels by SVG default).
+            try:
+                self._surface.set_document_unit(cairo.SVG_UNIT_PT)
+            except (AttributeError, TypeError):
+                # Older pycairo / cairo without set_document_unit — file is
+                # still well-formed, just unit-less.
+                pass
         elif surface_type == "ps":
             if filename is None:
                 raise ValueError("filename is required for PS surface")
@@ -322,6 +333,34 @@ class CairoRenderer(GridRenderer):
 
     # ---- gpar application --------------------------------------------------
 
+    def _lwd_to_user(self, lwd_pt: float) -> float:
+        """Convert R-grid lwd (points) to a Cairo user-space line width.
+
+        R's grid measures ``lwd`` in 1/72 inch (points) regardless of the
+        active viewport scale — a value of 1 should always produce a stroke
+        1pt wide on the output medium.  Cairo's ``set_line_width`` takes a
+        user-space distance, so we have to:
+
+        1. Map points → device units.  Raster ``ImageSurface`` has 1 user
+           unit = 1 pixel, so device units per point = ``dpi/72``.  Vector
+           surfaces (PDF/SVG/PS) have 1 user unit = 1 pt, so the conversion
+           factor is 1.0.  Equivalently, use ``_dev_units_per_inch / 72``.
+        2. Undo any active CTM scaling via ``device_to_user_distance`` so
+           that nested viewports (which scale the CTM) do not also scale
+           the stroke.
+
+        This is the analogue of the font-size handling in ``_set_font``.
+        """
+        if self._surface_type == "image":
+            lw_dev = lwd_pt * self.dpi / 72.0
+        else:
+            lw_dev = lwd_pt
+        try:
+            ux, uy = self._ctx.device_to_user_distance(lw_dev, lw_dev)
+            return max(abs(ux), abs(uy))
+        except Exception:
+            return lw_dev
+
     def _apply_stroke(self, gp: Optional[Gpar]) -> Tuple[float, float, float, float]:
         """Set stroke colour, line width, dash, caps, joins from Gpar.
 
@@ -331,7 +370,7 @@ class CairoRenderer(GridRenderer):
         ctx = self._ctx
         if gp is None:
             ctx.set_source_rgba(0, 0, 0, 1)
-            ctx.set_line_width(1.0)
+            ctx.set_line_width(self._lwd_to_user(1.0))
             return (0.0, 0.0, 0.0, 1.0)
 
         col = gp.get("col", None)
@@ -367,24 +406,7 @@ class CairoRenderer(GridRenderer):
         # R semantics: lwd=0 means invisible line
         if lw <= 0:
             return (0.0, 0.0, 0.0, 0.0)
-        # R grid semantics: ``lwd`` is always in **points** (1/72 inch)
-        # regardless of the current viewport's scale.  Cairo's
-        # ``set_line_width`` takes a user-space distance, which the
-        # viewport CTM has scaled down to NPC-like units — so a value
-        # of 0.5 user-space becomes sub-pixel after ``scale(w, h)``.
-        # Convert ``lw`` from points → device pixels using the
-        # renderer's DPI, then back to user-space via
-        # ``device_to_user_distance`` so the stroke width stays at
-        # 0.5pt on the output device no matter how deep the
-        # viewport stack is (matches R grid's device-unit lwd).
-        dpi = getattr(self, "dpi", None) or getattr(self, "_dpi", 72.0) or 72.0
-        lw_px = lw * dpi / 72.0
-        try:
-            ux, uy = ctx.device_to_user_distance(lw_px, lw_px)
-            lw_user = max(abs(ux), abs(uy))
-        except Exception:
-            lw_user = lw
-        ctx.set_line_width(lw_user)
+        ctx.set_line_width(self._lwd_to_user(lw))
 
         lty = gp.get("lty", None)
         if lty is not None:
@@ -1197,7 +1219,7 @@ class CairoRenderer(GridRenderer):
         """
         ctx.save()
         ctx.new_path()  # clear any residual path from prior draws
-        ctx.set_line_width(lwd)
+        ctx.set_line_width(self._lwd_to_user(lwd))
 
         if pch_val <= 14:
             # --- Group 0-14: stroke-only (use col for outline, no fill) ---

{rgrid_python-4.5.3.post1.dist-info → rgrid_python-4.5.3.post3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3.post1
+Version: 4.5.3.post3
 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

{rgrid_python-4.5.3.post1.dist-info → rgrid_python-4.5.3.post3.dist-info}/RECORD

@@ -1,42 +1,42 @@
-grid_py/__init__.py,sha256=VdXdkrNMRm9SmgzSnxFUa2RPcUY-OTkfvGToCE96RiQ,10506
+grid_py/__init__.py,sha256=tSRqBr3SxkmX3f3x0tT6G-kMFeApA6cjrhD1CGiKWNs,10520
 grid_py/_arrow.py,sha256=pgn4OCgF6TZY2yXl7ML-kt08DbwqlvT1ulApDcmRz4k,10867
 grid_py/_clippath.py,sha256=p6fUAkcEc5Bg8chv-lIZwaOjEUbLK57duwjtIpDjAkw,4015
 grid_py/_colour.py,sha256=WqaxGop-SM1LYZG4uMPmMX3Zjh6Y_ip0HcanP5wEij8,22872
 grid_py/_coords.py,sha256=9cDD3MWHmw9TnT1I8QKHQA96SCG06OxRXNqYGFZsfwg,47210
-grid_py/_curve.py,sha256=MV7hl1MR-4FZfKBKEm4MCSvHgJLYP9UaWLp8eHXPhv0,54041
+grid_py/_curve.py,sha256=QnUkh9lWLd0OSm7h7QwS78JjzBAu9WHmRY4ZpZhccpY,54989
 grid_py/_display_list.py,sha256=uMFAupSJaCgUCbLMv2-RDBQ-YLxCkAldypRqc7CnF3w,13622
-grid_py/_draw.py,sha256=PgvuOM3nAvGCh1LFOY1oYbSOQU6rTh8NFu_aHTbl1Ok,48620
+grid_py/_draw.py,sha256=WcbxIX9GPEZBf5L8KRZpYiFNWyHVttGBrroKO4m6LUY,50953
 grid_py/_edit.py,sha256=vQDZGBTTYy6DmlW33l94s1KJLrzPNym21NR4Od4qIFw,22263
 grid_py/_font_metrics.py,sha256=XC_dgIN3eB72VPXIRFU-tynnS3wJl3bPugGHrwVzyeo,11086
-grid_py/_gpar.py,sha256=N8DoESq2nBiGdIcdshdsRXWjmEC8CwBCL4yndAJwaPQ,19392
+grid_py/_gpar.py,sha256=AW3PNlD7UWOozzZvY5Y3f7ZGTWCTRnOs2YqOvlFD1_A,19757
 grid_py/_grab.py,sha256=XAPdYG2gyl9Px29xM_rByIPA2NwuvkbFaLcHGrqpaUQ,15423
 grid_py/_grob.py,sha256=kHSxkPHWqHHyMVum7ueKS-ddDqFF2E-8tUQOM-azEXU,39992
 grid_py/_group.py,sha256=jmPQPcy_lrVjurF8w5ovhCXvwKLBeGVkOwAvX0X0gA0,22828
 grid_py/_highlevel.py,sha256=KVcFc0aUm6WBGyNKlYJfZ16qC4bRolng8ZKb86lSLpc,61803
 grid_py/_just.py,sha256=lh9ar8lw6JRqZE5qHP4Wx7GHPIW0y7Wp0EgJ7vhFjek,10590
-grid_py/_layout.py,sha256=fYomioHrI--nHi8tC1X_fsv91QCRZ4E-g0F9hl6XW4c,19307
+grid_py/_layout.py,sha256=opOEvxTO2gjwuLEt8sbKjp4yexjnx0Gik6d95yoL3aI,19721
 grid_py/_ls.py,sha256=RhUGZJCZkcTUjUK97fft_G4D9KxuyBr3OMFhzC5IShc,25547
 grid_py/_mask.py,sha256=d2Wm2z-RJnfEKHdAHcjteL7VubimcaK1_f9Us9MfrUk,4902
 grid_py/_path.py,sha256=Tr5bNNcGwPpOsxWKqEp65MRri-KV8IqplUh2Z90sxnk,11421
 grid_py/_patterns.py,sha256=PBwV2b3oJkbueTLCku6cxeZ1PThREjiPcA6lmrwH3pE,32691
 grid_py/_primitives.py,sha256=dpX5_q5CS8p1vhuVzTa77MVbtaxigGBA5mmUzfFfHks,58861
-grid_py/_renderer_base.py,sha256=kY_mdcldRR94OBBcgEFg9cmIM3fUlbnUPdGiy-ulaSM,48701
+grid_py/_renderer_base.py,sha256=UD24cRzJlknMSSs2sl27XaDZ1e7XdIuhRDVhDxjiW-o,54770
 grid_py/_scene_graph.py,sha256=mKhNEMkUolbWt4_CFgGhrGUudrYenxFNXaBp6GLN9_Y,7412
-grid_py/_size.py,sha256=NuzLD567ywRYyhSPWna9CA2ScxtCWgV1BWpt_ot0Txs,41962
-grid_py/_state.py,sha256=GiOMFQozol_SInRoxUZ5TXsFLOBwuNs7EWWi19WFiWM,20598
+grid_py/_size.py,sha256=q9yYdhO7dcp-RtQzJIIsXssFH5oFbsm5_P6UxZlFKjg,43312
+grid_py/_state.py,sha256=SsEzcicTmxWaGExDeLLNNVXT-G38aUFtgSuZTJEYBbw,22800
 grid_py/_transforms.py,sha256=mQvs_Qm6icti66peLXTsjgmSmvIUCCphf_-D-tiE1O4,11675
 grid_py/_typeset.py,sha256=J_PJ5YcOAOnnFkBfo8IW86utJdkdsrnGZi3MvnHc8io,11516
-grid_py/_units.py,sha256=bbpzFW1iJjxvZi3J9nFwcB9XnnDcpPkmqHh0IeIRIjs,61141
+grid_py/_units.py,sha256=bGrHV23Vr2A6lO15LJvcP7Qs1Yx_uQJLmyQ6bRB3yjc,61893
 grid_py/_utils.py,sha256=QaWNkCF3BbPHyrqPPRxN7Ji2vB5ethNwVT3SJ1ad9Lc,8335
 grid_py/_viewport.py,sha256=AOrYmv05Y4QJbsTksn86RLStfHdbOHERc2YDHdZAekE,48477
 grid_py/_vp_calc.py,sha256=v0MJc-YmWohO5t7LHFopk5ogH-Sink_A_zNFV_1769w,32935
 grid_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-grid_py/renderer.py,sha256=hzCRgHMrR8tFpsdqT1al09gnZhgShoe_kIEO4MTYZNY,61620
+grid_py/renderer.py,sha256=6L6Rb-2AfjmvaeQYhWQKlU1L1HYHkKAma03v6YdZcTk,62658
 grid_py/renderer_web.py,sha256=pbOijES1eUUqkeAadXVyZPCBRIUIgzs3HIOgAElTYmo,27958
 grid_py/resources/d3.v7.min.js,sha256=8glLv2FBs1lyLE_kVOtsSw8OQswQzHr5IfwVj864ZTk,279706
 grid_py/resources/gridpy.css,sha256=tR5LF2rLvi_bGRWuH9CnmLQk-aG2f-jlZjQZqS7_4uY,1351
 grid_py/resources/gridpy.js,sha256=l8KGgK-qZbJPVvrMAmLUu57RhpSAo_LMibs6rx3RnvA,28340
-rgrid_python-4.5.3.post1.dist-info/METADATA,sha256=zIT-8WOTDRcuOiWBEQz8a8R4821YTJ4_6ajLaGYTkwE,19910
-rgrid_python-4.5.3.post1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-rgrid_python-4.5.3.post1.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
-rgrid_python-4.5.3.post1.dist-info/RECORD,,
+rgrid_python-4.5.3.post3.dist-info/METADATA,sha256=U2Lx9ccpNvIWTBozFmqItTD-AWHPY9Wq9zdeKQelK68,19910
+rgrid_python-4.5.3.post3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rgrid_python-4.5.3.post3.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
+rgrid_python-4.5.3.post3.dist-info/RECORD,,