rgrid-python 4.5.3.post1__tar.gz → 4.5.3.post4__tar.gz

{rgrid_python-4.5.3.post1 → rgrid_python-4.5.3.post4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3.post1
+Version: 4.5.3.post4
 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 → rgrid_python-4.5.3.post4}/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.post4"
 
 # --- 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

{rgrid_python-4.5.3.post1 → rgrid_python-4.5.3.post4}/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,
     )

{rgrid_python-4.5.3.post1 → rgrid_python-4.5.3.post4}/grid_py/_draw.py

@@ -215,7 +215,12 @@ def _draw_arrow_heads(
     try:
         l_w = float(renderer.resolve_w(length_unit, gp=gp))
         l_h = float(renderer.resolve_h(length_unit, gp=gp))
-    except Exception:
+    except (ValueError, AttributeError, TypeError) as exc:
+        warnings.warn(
+            f"arrow length cannot be resolved ({exc}); arrow head skipped",
+            UserWarning,
+            stacklevel=2,
+        )
         return
     length_dev = min(l_w, l_h)
     if not (length_dev > 0):
@@ -412,7 +417,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 +449,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 +589,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 +718,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.post1 → rgrid_python-4.5.3.post4}/grid_py/_gpar.py

@@ -14,20 +14,18 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 import numpy as np
 
-__all__ = ["Gpar", "get_gpar"]
+__all__ = ["Gpar", "gpar", "get_gpar"]
 
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
 
-_VALID_LTY: set[str] = {
-    "solid",
-    "dashed",
-    "dotted",
-    "dotdash",
-    "longdash",
-    "twodash",
-}
+# Derived from grid_py._lty so there is exactly one source of truth for
+# the named-lty set.  ``"blank"`` is added because R par/grid accepts it
+# even though it has no hex equivalent (it short-circuits the stroke).
+from ._lty import valid_named_lty as _valid_named_lty
+
+_VALID_LTY: frozenset[str] = _valid_named_lty()
 
 _VALID_LINEEND: set[str] = {"round", "butt", "square"}
 
@@ -77,9 +75,12 @@ def _as_list(value: Any) -> list:
     return [value]
 
 
-def _is_hex_lty(s: str) -> bool:
-    """Return True when *s* looks like a valid hex-string line-type spec."""
-    return all(c in "0123456789abcdefABCDEF" for c in s) and len(s) > 0
+# NOTE: ``_is_hex_lty`` used to live here.  It has been removed because
+# hex-string validity is now decided by ``grid_py._lty.resolve_lty``,
+# which is the single source of truth for both "is this lty valid?" and
+# "what dash array does it expand to?".  Keeping a separate validator
+# here would create the same kind of dual-source landmine that
+# motivated B7 in the first place.
 
 
 def _resolve_fontface(value: Any) -> int:
@@ -254,14 +255,19 @@ class Gpar:
                     ) from exc
 
             elif name == "lty":
+                # Validation delegates to grid_py._lty so accept/reject
+                # decisions match the renderer-time resolver exactly.
+                # ``resolve_lty`` raises ValueError on bad input with a
+                # message already containing the offending value, so we
+                # let it propagate (no try/except — principle 4).
+                from ._lty import is_blank_lty, resolve_lty
                 for v in vals:
-                    if isinstance(v, str):
-                        if v not in _VALID_LTY and not _is_hex_lty(v):
-                            raise ValueError(
-                                f"invalid line type '{v}'; must be one of "
-                                f"{sorted(_VALID_LTY)} or a hex string"
-                            )
-                    elif not isinstance(v, (int, float, np.integer, np.floating)):
+                    if is_blank_lty(v):
+                        continue
+                    if isinstance(v, (str, int, float, np.integer, np.floating)) \
+                       and not isinstance(v, bool):
+                        resolve_lty(v)   # raises ValueError if invalid
+                    else:
                         raise TypeError(
                             f"'lty' must be str or numeric, got {type(v).__name__}"
                         )
@@ -462,6 +468,26 @@ class Gpar:
         gp._params = merged
         return gp
 
+    # -- mod (R: mod.gpar) -------------------------------------------------
+
+    def _mod(self, new_gp: "Gpar") -> "Gpar":
+        """Edit-time merge (R ``mod.gpar`` — gpar.R:298-304).
+
+        Plain key overwrite — ``new_gp``'s keys replace ``self``'s keys,
+        unmentioned keys are kept unchanged. Unlike :meth:`_merge`
+        (which mirrors R ``set.gpar`` and multiplies cumulative
+        params like ``cex`` / ``alpha`` / ``lex``), this method is the
+        one used by ``editGrob`` and does NOT multiply — R's
+        ``mod.gpar`` does a single ``gp[names(newgp)] <- newgp``.
+        """
+        if not self._params:
+            return new_gp
+        merged = copy.deepcopy(self._params)
+        merged.update(copy.deepcopy(new_gp._params))
+        gp = object.__new__(Gpar)
+        gp._params = merged
+        return gp
+
     # -- display -----------------------------------------------------------
 
     def __repr__(self) -> str:
@@ -586,3 +612,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.post1 → rgrid_python-4.5.3.post4}/grid_py/_grob.py

@@ -1157,12 +1157,15 @@ def _edit_this_grob(grob: Grob, specs: dict[str, Any]) -> Grob:
         if not key:
             continue
         if key == "gp":
-            # Special handling: merge gpar
+            # Special handling — R editGrob uses ``mod.gpar`` (gpar.R:298-304)
+            # which does a plain key overwrite (``gp[names(newgp)] <- newgp``)
+            # *without* the cumulative cex/alpha/lex multiplication that
+            # viewport-push's ``set.gpar`` applies. ``Gpar._mod`` is the
+            # mirror; ``Gpar._merge`` is the cumulative one.
             if value is None:
                 grob._gp = None
             elif grob._gp is not None:
-                # Merge new gp on top of existing
-                grob._gp = grob._gp.merge(value) if hasattr(grob._gp, "merge") else value
+                grob._gp = grob._gp._mod(value)
             else:
                 grob._gp = value
         elif key == "name":

{rgrid_python-4.5.3.post1 → rgrid_python-4.5.3.post4}/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.post4/grid_py/_lty.py

@@ -0,0 +1,197 @@
+"""Linetype resolution — R-faithful port of GE_LTYpar + CairoLineType.
+
+This is the single source of truth for translating any R-accepted lty
+specification (named string, R integer 0..6, hex string of length
+{2,4,6,8}) into a Cairo / SVG ready dash array.  Both the Cairo and the
+Web renderers consume the same ``resolve_lty`` output, so any lty
+behaviour fix lands in exactly one place.
+
+R reference (R 4.5.3):
+    src/include/R_ext/GraphicsEngine.h:406-412   (LTY_* constants)
+    src/main/engine.c::GE_LTYpar                 (string -> 32-bit int)
+    src/library/grDevices/src/cairoFns.c::CairoLineType
+                                                 (int -> dash array)
+
+The cairo-dash scaling factor is *1.0*: ``set_dash([nibble * lwd, ...])``.
+This was empirically verified by reverse-engineering R's cairo PNG output
+(lty="44" at lwd in {1, 1.5, 2, 4, 6, 8} matches ``period = 2*nibble*lwd
++ 2*cap``, where cap ~= lwd for the default lineend="round").  A 0.75
+factor that appeared in early drafts of this file was a memory error
+(possibly conflated with a non-cairo R device) and would cause every
+dash pattern to shrink by 25 %.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Sequence, Union
+
+import numpy as np
+
+__all__ = [
+    "resolve_lty",
+    "is_blank_lty",
+    "valid_named_lty",
+]
+
+
+# ---------------------------------------------------------------------------
+# R-gold constants (verbatim from R source, do not edit without R reference)
+# ---------------------------------------------------------------------------
+
+# GraphicsEngine.h:407-412 — every named lty is *also* expressible as a
+# hex string, so resolve_lty has a single parser code path.  Low nibble
+# of the integer constant sits in the leftmost character of the hex
+# string (R's GE_LTYpar packs bits low-to-high as it scans left-to-right).
+#   LTY_SOLID    = 0          ""
+#   LTY_DASHED   = 0x44       "44"
+#   LTY_DOTTED   = 0x31       -> low nibble 1, high nibble 3 -> "13"
+#   LTY_DOTDASH  = 0x3431                                     "1343"
+#   LTY_LONGDASH = 0x37                                       "73"
+#   LTY_TWODASH  = 0x2622                                     "2262"
+_LTY_NAMED_TO_HEX: dict[str, str] = {
+    "solid":    "",
+    "dashed":   "44",
+    "dotted":   "13",
+    "dotdash":  "1343",
+    "longdash": "73",
+    "twodash":  "2262",
+}
+
+# R ?par integer codes (user-facing).  Note that "user-facing 0" is BLANK,
+# *not* the internal LTY_SOLID=0 constant: GE_LTYpar maps user 0 -> internal
+# LTY_BLANK (-1) and user 1 -> internal LTY_SOLID (0).
+_LTY_INT_TO_NAME: dict[int, str] = {
+    1: "solid",
+    2: "dashed",
+    3: "dotted",
+    4: "dotdash",
+    5: "longdash",
+    6: "twodash",
+}
+
+# R-gold (empirically verified): GE_LTYpar rejects any hex string whose
+# length is not in {2, 4, 6, 8}.  Single nibble "F" -> "invalid line
+# type: must be length 2, 4, 6 or 8".
+_LTY_VALID_HEX_LENS: frozenset[int] = frozenset({2, 4, 6, 8})
+
+LtyInput = Union[str, int, float, None, list, tuple, np.ndarray]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def valid_named_lty() -> frozenset[str]:
+    """Set of R named lty values accepted by Gpar (includes ``"blank"``)."""
+    return frozenset(_LTY_NAMED_TO_HEX.keys()) | {"blank"}
+
+
+def is_blank_lty(value: LtyInput) -> bool:
+    """True iff *value* represents R LTY_BLANK (caller should skip stroke).
+
+    Mirrors R par convention:
+      * user-facing integer 0   -> blank
+      * "blank" (string)        -> blank
+      * NA / None inside a Gpar list sentinel  -> blank
+      * **but** scalar ``None`` (no lty supplied) -> not blank (= solid)
+      * **but** string ``"0"`` -> not blank (R rejects len-1 hex; see
+        resolve_lty); we follow R's quirk and only treat *integer* 0 as
+        blank, not string "0".
+    """
+    if value is None:
+        return False
+    raw = value[0] if isinstance(value, (list, tuple, np.ndarray)) and len(value) else value
+    if raw is None:
+        return True
+    if isinstance(raw, (int, float, np.integer, np.floating)) and not isinstance(raw, bool):
+        return int(raw) == 0
+    return str(raw).lower() == "blank"
+
+
+def resolve_lty(value: LtyInput, lwd: float = 1.0) -> Optional[list[float]]:
+    """Resolve any R-accepted lty input into a Cairo-ready dash array.
+
+    Parameters
+    ----------
+    value : str | int | float | None | sequence
+        - ``None``                       -> solid
+        - One of ``valid_named_lty()``   -> the canonical hex pattern
+        - Hex string, length in {2,4,6,8} with chars [0-9A-Fa-f]
+        - Integer in 1..6 (R par convention; 0 is BLANK and must be
+          caught by ``is_blank_lty`` *before* calling this function)
+        - List/tuple/ndarray: first element is used (R recycling rule
+          is the caller's job)
+
+    Returns
+    -------
+    None or list[float]
+        - ``None`` for solid (no dashing)
+        - Otherwise the cairo ``set_dash`` array.  Each element is
+          ``hex_digit * lwd`` user-space units (or whatever space the
+          caller's ``lwd`` lives in — caller must keep lwd and dash in
+          the same coordinate system).
+
+    Raises
+    ------
+    ValueError
+        On unrecognised input.  Caller must invoke ``is_blank_lty``
+        first; passing a blank-representing value here raises.
+    """
+    if value is None:
+        return None
+    raw = value[0] if isinstance(value, (list, tuple, np.ndarray)) and len(value) else value
+    if raw is None:
+        # Caller forgot to short-circuit via is_blank_lty.  Fail loud
+        # (per principle 4 — do not silently convert blank to solid).
+        raise ValueError(
+            "blank lty (NA sentinel) must be handled by caller via is_blank_lty()"
+        )
+
+    # R integer path — par convention 1..6 (0 is BLANK, handled by caller).
+    if isinstance(raw, (int, float, np.integer, np.floating)) and not isinstance(raw, bool):
+        i = int(raw)
+        if i == 0:
+            raise ValueError(
+                "lty=0 is BLANK; caller must check is_blank_lty() before resolve_lty()"
+            )
+        if i not in _LTY_INT_TO_NAME:
+            raise ValueError(f"Invalid integer lty: {i!r} (must be in 1..6)")
+        raw = _LTY_INT_TO_NAME[i]
+
+    s = str(raw)
+
+    # Named lty -> canonical hex (single parser path below for both forms)
+    if s in _LTY_NAMED_TO_HEX:
+        s = _LTY_NAMED_TO_HEX[s]
+
+    if s == "":
+        return None   # solid
+
+    # Hex string validation — R GE_LTYpar rules (empirically verified):
+    #   non-hex char        -> "invalid hex digit in 'color' or 'lty'"
+    #   length not in 2/4/6/8 -> "invalid line type: must be length 2, 4, 6 or 8"
+    if not all(c in "0123456789abcdefABCDEF" for c in s):
+        raise ValueError(f"Invalid lty: {s!r} (invalid hex digit)")
+    if len(s) not in _LTY_VALID_HEX_LENS:
+        raise ValueError(
+            f"Invalid lty: {s!r} (length {len(s)} not in {{2,4,6,8}})"
+        )
+
+    # Cairo dash expansion — equivalent to R cairoFns.c::CairoLineType:
+    #     while (l < 8 && lty != 0) {
+    #         dt = lty & 15;
+    #         if (dt == 0) break;     // zero nibble terminates pattern
+    #         ls[l] = dt * lwd;       // scale factor 1.0 (R-verified)
+    #         lty = lty >> 4;
+    #         l++;
+    #     }
+    # R's length pre-check guarantees s is len 2/4/6/8, so the only place a
+    # zero nibble appears is at the *end* of a longer pattern (e.g. "4400"
+    # legitimately means [4, 4] then stop).
+    dashes: list[float] = []
+    for c in s:
+        d = int(c, 16)
+        if d == 0:
+            break
+        dashes.append(d * lwd)
+    return dashes if dashes else None

{rgrid_python-4.5.3.post1 → rgrid_python-4.5.3.post4}/grid_py/_patterns.py

@@ -914,8 +914,13 @@ def _resolve_linear_gradient(grad: LinearGradient) -> ResolvedPattern:
             "stops": grad.stops,
             "extend": grad.extend,
         }
-    except Exception:
-        # Fallback: store the original gradient for later resolution
+    except (ValueError, AttributeError, TypeError, IndexError):
+        # Documented deferred-resolution fallback: when the gradient's
+        # endpoint Units can't be resolved against the current
+        # renderer state (e.g. ``"npc"`` outside a viewport), stash the
+        # original gradient so the renderer can resolve it later. R's
+        # ``resolvePattern.GridLinearGradient`` (patterns.R:401-418)
+        # delegates the same way via lazy attr lookup.
         ref = {"type": "linear_gradient", "pattern": grad}
 
     return ResolvedPattern(grad, ref)
@@ -949,7 +954,8 @@ def _resolve_radial_gradient(grad: RadialGradient) -> ResolvedPattern:
             "stops": grad.stops,
             "extend": grad.extend,
         }
-    except Exception:
+    except (ValueError, AttributeError, TypeError, IndexError):
+        # Deferred-resolution fallback — see ``_resolve_linear_gradient``.
         ref = {"type": "radial_gradient", "pattern": grad}
 
     return ResolvedPattern(grad, ref)
@@ -974,7 +980,8 @@ def _resolve_tiling_pattern(pat: Pattern) -> ResolvedPattern:
             "width": float(wh["w"][0]), "height": float(wh["h"][0]),
             "extend": pat.extend,
         }
-    except Exception:
+    except (ValueError, AttributeError, TypeError, IndexError):
+        # Deferred-resolution fallback — see ``_resolve_linear_gradient``.
         ref = {"type": "tiling_pattern", "pattern": pat}
 
     return ResolvedPattern(pat, ref)