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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3.post2
+Version: 4.5.3.post5
 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.post2 → rgrid_python-4.5.3.post5}/grid_py/__init__.py

@@ -6,7 +6,7 @@ units, viewports, grobs (graphical objects), layouts, and rendering via
 Cairo (pycairo).
 """
 
-__version__ = "4.5.3.post2"
+__version__ = "4.5.3.post5"
 
 # --- Utilities ---
 from grid_py._utils import depth, explode, grid_pretty, n2mfrow

{rgrid_python-4.5.3.post2 → rgrid_python-4.5.3.post5}/grid_py/_colour.py

@@ -761,8 +761,15 @@ def parse_r_colour(c: Any) -> Tuple[float, float, float, float]:
         s = c.strip()
         low = s.lower()
 
-        # Transparent / NA
-        if low in ("transparent", "na", "none", ""):
+        # R's ``col2rgb("transparent", alpha=TRUE)`` returns (255, 255, 255, 0)
+        # — by R convention the RGB channels are white even though α=0
+        # makes the colour invisible.  Mirror exactly so hex round-trips
+        # and downstream tooling that compares against R's encoding agree.
+        if low == "transparent":
+            return (1.0, 1.0, 1.0, 0.0)
+        # NA / none / "" are Python-port-specific transparent sentinels not
+        # defined as parseable colours in R (``col2rgb('NA')`` errors).
+        if low in ("na", "none", ""):
             return (0.0, 0.0, 0.0, 0.0)
 
         # Hex colour

{rgrid_python-4.5.3.post2 → rgrid_python-4.5.3.post5}/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.post2 → rgrid_python-4.5.3.post5}/grid_py/_draw.py

@@ -25,6 +25,7 @@ from ._state import get_state
 from ._display_list import DisplayList, DLDrawGrob
 from ._units import Unit
 from ._utils import grid_pretty as _grid_pretty
+from ._primitives import valid_pch
 
 __all__ = [
     "grid_draw",
@@ -215,7 +216,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):
@@ -302,8 +308,16 @@ def _render_grob(
 
     # ---- rect -----------------------------------------------------------
     if cls == "rect":
-        xs = renderer.resolve_x_array(getattr(grob, "x", [0.0]), gp=gp)
-        ys = renderer.resolve_y_array(getattr(grob, "y", [0.0]), gp=gp)
+        # Use paired resolve_loc_array so that under a rotated viewport
+        # each rect's anchor (x_i, y_i) is mapped through the full 2-D
+        # CTM together, not via two independent 1-D projections (which
+        # silently drop the rotation contribution from the orthogonal
+        # axis — see _renderer_base.resolve_x_array docstring).
+        xs, ys = renderer.resolve_loc_array(
+            getattr(grob, "x", [0.0]),
+            getattr(grob, "y", [0.0]),
+            gp=gp,
+        )
         ws = renderer.resolve_w_array(getattr(grob, "width", [1.0]), gp=gp)
         hs = renderer.resolve_h_array(getattr(grob, "height", [1.0]), gp=gp)
         hj, vj = _resolve_just(grob)
@@ -326,9 +340,11 @@ def _render_grob(
 
     # ---- roundrect ------------------------------------------------------
     elif cls == "roundrect":
+        ax, ay = renderer.resolve_loc(
+            getattr(grob, "x", 0.0), getattr(grob, "y", 0.0), gp=gp,
+        )
         renderer.draw_roundrect(
-            x=renderer.resolve_x(getattr(grob, "x", 0.0), gp=gp),
-            y=renderer.resolve_y(getattr(grob, "y", 0.0), gp=gp),
+            x=ax, y=ay,
             w=renderer.resolve_w(getattr(grob, "width", 1.0), gp=gp),
             h=renderer.resolve_h(getattr(grob, "height", 1.0), gp=gp),
             r=renderer.resolve_w(getattr(grob, "r", 0.0), gp=gp),
@@ -339,17 +355,22 @@ def _render_grob(
 
     # ---- circle ---------------------------------------------------------
     elif cls == "circle":
+        cx, cy = renderer.resolve_loc(
+            getattr(grob, "x", 0.5), getattr(grob, "y", 0.5), gp=gp,
+        )
         renderer.draw_circle(
-            x=renderer.resolve_x(getattr(grob, "x", 0.5), gp=gp),
-            y=renderer.resolve_y(getattr(grob, "y", 0.5), gp=gp),
+            x=cx, y=cy,
             r=renderer.resolve_w(getattr(grob, "r", 0.5), gp=gp),
             gp=gp,
         )
 
     # ---- lines / polyline ------------------------------------------------
     elif cls in ("lines", "polyline"):
-        x = renderer.resolve_x_array(getattr(grob, "x", [0.0, 1.0]), gp=gp)
-        y = renderer.resolve_y_array(getattr(grob, "y", [0.0, 1.0]), gp=gp)
+        x, y = renderer.resolve_loc_array(
+            getattr(grob, "x", [0.0, 1.0]),
+            getattr(grob, "y", [0.0, 1.0]),
+            gp=gp,
+        )
         id_ = getattr(grob, "id", None)
         id_lengths = getattr(grob, "id_lengths", None)
         # R polylineGrob supports either `id` (per-point group) or
@@ -363,12 +384,36 @@ def _render_grob(
             id_ = np.atleast_1d(np.asarray(id_, dtype=int))
         renderer.draw_polyline(x, y, id_=id_, gp=gp)
 
+        # R linesGrob / polylineGrob carry an optional ``arrow=`` (port
+        # of src/grid.c::L_lines / L_polyline arrowhead emission).  The
+        # earlier code consumed it for ``segmentsGrob`` only, silently
+        # dropping it on lines / polyline — symptom: an arrow= argument
+        # produced a bare line.  Apply ``_draw_arrow_heads`` per
+        # polyline (each unique id) here, with the same reference-point
+        # convention segments uses.
+        arr = getattr(grob, "arrow", None)
+        if arr is not None:
+            if id_ is not None:
+                for uid in np.unique(id_):
+                    mask = id_ == uid
+                    if int(np.sum(mask)) >= 2:
+                        _draw_arrow_heads(
+                            np.asarray(x)[mask], np.asarray(y)[mask],
+                            arr, renderer, gp,
+                        )
+            elif len(x) >= 2:
+                _draw_arrow_heads(
+                    np.asarray(x), np.asarray(y), arr, renderer, gp,
+                )
+
     # ---- segments --------------------------------------------------------
     elif cls == "segments":
-        x0 = renderer.resolve_x_array(getattr(grob, "x0", []), gp=gp)
-        y0 = renderer.resolve_y_array(getattr(grob, "y0", []), gp=gp)
-        x1 = renderer.resolve_x_array(getattr(grob, "x1", []), gp=gp)
-        y1 = renderer.resolve_y_array(getattr(grob, "y1", []), gp=gp)
+        x0, y0 = renderer.resolve_loc_array(
+            getattr(grob, "x0", []), getattr(grob, "y0", []), gp=gp,
+        )
+        x1, y1 = renderer.resolve_loc_array(
+            getattr(grob, "x1", []), getattr(grob, "y1", []), gp=gp,
+        )
         renderer.draw_segments(x0=x0, y0=y0, x1=x1, y1=y1, gp=gp)
 
         # Each segment may carry its own arrowhead (``arrow=`` parameter on
@@ -387,8 +432,11 @@ def _render_grob(
     elif cls == "xspline":
         from ._curve import _calc_xspline_points  # lazy to avoid import cycle
 
-        x = renderer.resolve_x_array(getattr(grob, "x", [0.0, 1.0]), gp=gp)
-        y = renderer.resolve_y_array(getattr(grob, "y", [0.0, 1.0]), gp=gp)
+        x, y = renderer.resolve_loc_array(
+            getattr(grob, "x", [0.0, 1.0]),
+            getattr(grob, "y", [0.0, 1.0]),
+            gp=gp,
+        )
         shape_raw = getattr(grob, "shape", 0.0)
         open_ = bool(getattr(grob, "open_", True))
         rep_ends = bool(getattr(grob, "repEnds", True))
@@ -412,7 +460,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 +492,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:
@@ -449,8 +517,9 @@ def _render_grob(
 
     # ---- polygon ---------------------------------------------------------
     elif cls == "polygon":
-        px = renderer.resolve_x_array(getattr(grob, "x", []), gp=gp)
-        py = renderer.resolve_y_array(getattr(grob, "y", []), gp=gp)
+        px, py = renderer.resolve_loc_array(
+            getattr(grob, "x", []), getattr(grob, "y", []), gp=gp,
+        )
         pid = getattr(grob, "id", None)
         if pid is not None:
             # R semantics: polygonGrob(id=...) draws separate polygons
@@ -484,9 +553,8 @@ def _render_grob(
         else:
             labels = [str(label_raw)]
 
-        # Resolve x/y to arrays
-        xx = renderer.resolve_x_array(x_unit, gp=gp)
-        yy = renderer.resolve_y_array(y_unit, gp=gp)
+        # Resolve x/y as pairs so rotation contribution is preserved.
+        xx, yy = renderer.resolve_loc_array(x_unit, y_unit, gp=gp)
 
         # Normalise rot to array
         if isinstance(rot_raw, (list, tuple, np.ndarray)):
@@ -528,16 +596,20 @@ def _render_grob(
     # ---- points ----------------------------------------------------------
     elif cls == "points":
         pch_raw = getattr(grob, "pch", 19)
-        # pch may be a scalar or per-point array — pass through as-is
-        if isinstance(pch_raw, (np.ndarray, list, tuple)):
-            pch_val = np.asarray(pch_raw, dtype=int)
-        elif isinstance(pch_raw, (int, float, np.integer, np.floating)):
-            pch_val = int(pch_raw)
-        else:
-            pch_val = 19
+        # pch may be a scalar (int or single character such as "."/"A")
+        # or a per-point array (possibly MIXED int/str, e.g.
+        # [".", 19, "A"]).  R keeps character pch as character and
+        # coerces numeric pch to int (grid:::valid.pch).  Normalise via
+        # the same helper and pass the result through *unchanged* — the
+        # renderer dispatches symbol-vs-glyph per point.  Do NOT force
+        # ``dtype=int`` (that crashes on "."), and do NOT substitute a
+        # silent default for non-numeric scalars (that masks bugs).
+        pch_val = valid_pch(pch_raw)
+        pts_x, pts_y = renderer.resolve_loc_array(
+            getattr(grob, "x", []), getattr(grob, "y", []), gp=gp,
+        )
         renderer.draw_points(
-            x=renderer.resolve_x_array(getattr(grob, "x", []), gp=gp),
-            y=renderer.resolve_y_array(getattr(grob, "y", []), gp=gp),
+            x=pts_x, y=pts_y,
             size=renderer.resolve_w(getattr(grob, "size", 1.0), gp=gp),
             pch=pch_val,
             gp=gp,
@@ -545,18 +617,63 @@ def _render_grob(
 
     # ---- pathgrob --------------------------------------------------------
     elif cls == "pathgrob":
-        x = renderer.resolve_x_array(getattr(grob, "x", []), gp=gp)
-        y = renderer.resolve_y_array(getattr(grob, "y", []), gp=gp)
-        path_id = getattr(grob, "pathId", None)
+        x, y = renderer.resolve_loc_array(
+            getattr(grob, "x", []), getattr(grob, "y", []), gp=gp,
+        )
+        # R ``pathGrob`` carries two grouping levels (src/grid.c::L_path):
+        #
+        #   - id / id_lengths : per-point SUB-PATH identifier — each
+        #     unique value is one closed Cairo sub-path.
+        #   - path_id / path_id_lengths : per-sub-path COMPOUND grouping
+        #     — each compound is filled+stroked independently with its
+        #     own fill rule application.
+        #
+        # The earlier port read ``grob.pathId`` (camelCase, never stored
+        # by path_grob) and ignored ``grob.id`` entirely, so every path
+        # collapsed into a single 8-vertex sub-path that connected the
+        # two rectangles into a bow-tie.  Read both attributes properly
+        # here and pass the per-point sub-path identifier through to
+        # ``draw_path`` (which iterates unique values).
+        sub_id = getattr(grob, "id", None)
+        sub_id_lengths = getattr(grob, "id_lengths", None)
+        if sub_id is None and sub_id_lengths is not None:
+            lengths = np.atleast_1d(np.asarray(sub_id_lengths, dtype=int))
+            sub_id = np.repeat(np.arange(1, len(lengths) + 1), lengths)
+        if sub_id is None:
+            sub_id = np.ones(len(x), dtype=int)
+        else:
+            sub_id = np.atleast_1d(np.asarray(sub_id, dtype=int))
+
+        # Optional second-level compound grouping.  R fills each
+        # compound separately with its own fill-rule application.  Most
+        # uses (and every current test) have a single compound; we
+        # iterate when more are supplied.
+        path_id = getattr(grob, "path_id", None)
+        path_id_lengths = getattr(grob, "path_id_lengths", None)
+        if path_id is None and path_id_lengths is not None:
+            lengths = np.atleast_1d(np.asarray(path_id_lengths, dtype=int))
+            path_id = np.repeat(np.arange(1, len(lengths) + 1), lengths)
+        rule = getattr(grob, "rule", "winding")
+
         if path_id is None:
-            path_id = np.ones(len(x), dtype=int)
+            renderer.draw_path(
+                x=x, y=y, path_id=sub_id, rule=rule, gp=gp,
+            )
         else:
-            path_id = np.atleast_1d(np.asarray(path_id, dtype=int))
-        renderer.draw_path(
-            x=x, y=y, path_id=path_id,
-            rule=getattr(grob, "rule", "winding"),
-            gp=gp,
-        )
+            # Map per-point compound id from per-sub-path path_id.
+            path_id_arr = np.atleast_1d(np.asarray(path_id, dtype=int))
+            unique_subs = np.unique(sub_id)
+            sub_to_compound = {int(s): int(path_id_arr[k % len(path_id_arr)])
+                               for k, s in enumerate(unique_subs)}
+            point_compound = np.asarray(
+                [sub_to_compound[int(s)] for s in sub_id], dtype=int,
+            )
+            for ck in np.unique(point_compound):
+                mask = point_compound == ck
+                renderer.draw_path(
+                    x=x[mask], y=y[mask], path_id=sub_id[mask],
+                    rule=rule, gp=gp,
+                )
 
     # ---- rastergrob ------------------------------------------------------
     elif cls == "rastergrob":
@@ -564,15 +681,19 @@ 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_x, raw_y = renderer.resolve_loc(
+                getattr(grob, "x", 0.0), 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,

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

@@ -20,14 +20,12 @@ __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:

{rgrid_python-4.5.3.post2 → rgrid_python-4.5.3.post5}/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":