jarvisplot 2.1.2__tar.gz → 2.1.4__tar.gz

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.2
+Version: 2.1.4
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/JarvisPLOT.egg-info/SOURCES.txt

@@ -227,6 +227,7 @@ tests/test_method_contracts.py
 tests/test_parse_data_metadata.py
 tests/test_pathing_contracts.py
 tests/test_posterior_hpd.py
+tests/test_profile_runtime.py
 tests/test_render_health.py
 tests/test_row_ledger.py
 tests/test_schema_catalog.py

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.2
+Version: 2.1.4
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/Figure/corrplot_runtime.py

@@ -45,10 +45,15 @@ GLYPHS = ("circle", "square", "ellipse", "color", "shade", "pie", "number")
 
 _TRIANGLES = ("full", "upper", "lower")
 
+#: What the tint may be told to mean.  `selected` is the author's own grouping,
+#: `alternate` the figure's own, `none` nothing.
+_STRIPES = ("alternate", "selected", "none")
+
 #: Formals resolved at config time.  They arrive because the user wrote them
 #: in the layer, and are dropped here rather than forwarded to matplotlib.
 _CONFIG_TIME = ("order", "hclust.method", "addrect", "col", "tl.pos", "tl.cex",
-                "tl.col", "tl.srt", "tl.offset", "cl.cex", "edge.numbers.cex")
+                "tl.col", "tl.srt", "tl.offset", "cl.cex", "edge.numbers.cex",
+                "stripe.variables")
 
 
 def _pop(kwargs: dict, name: str, default=None):
@@ -270,14 +275,25 @@ def _notch_vertices(n: int, side: str = "left", diag: bool = False):
     )
 
 
-def _shaded_variables(n: int, blocks=None) -> np.ndarray:
-    """Which variables carry the tint: alternate blocks, or alternate names.
+def _shaded_variables(n: int, blocks=None, selected=None) -> np.ndarray:
+    """Which variables carry the tint.
+
+    Three answers, and they say different things.  ``selected`` is an explicit
+    set of positions -- the author naming the variables that matter, so the
+    tint is *their* grouping and nothing is inferred.  Otherwise it is read off
+    the figure: alternate **blocks** when the clustering cut some, so the
+    shading says where one group ends and the next begins (which is what the
+    boxes were for), and alternate **names** when it did not.
 
-    A block is a run of adjacent positions cut from the clustering tree, so
-    tinting every other one makes the shading say where one group ends and the
-    next begins -- which is what the boxes were for.
+    ``selected`` arrives as positions, not names: the order is settled at
+    config time and only the order knows which position a name ended up at.
     """
     shaded = np.zeros(int(n), dtype=bool)
+    if selected is not None:
+        for position in selected:
+            if 0 <= int(position) < int(n):
+                shaded[int(position)] = True
+        return shaded
     if blocks:
         for position, (start, end) in enumerate(blocks):
             if position % 2 == 0:
@@ -728,9 +744,21 @@ def draw_corrplot(ax, **kwargs):
     # Diamond only.  See the stripe block below for why it is not decoration.
     stripe = _pop(kwargs, "stripe", "alternate")
     stripe = "none" if stripe is False else str(stripe).strip().lower()
-    if stripe not in ("alternate", "none"):
+    if stripe not in _STRIPES:
+        raise ValueError(
+            "corrplot stripe must be one of {}; got {!r}. `selected` takes the "
+            "variables to tint in `stripe.variables`.".format(
+                ", ".join(_STRIPES), stripe
+            )
+        )
+    # Positions, resolved from `stripe.variables` at config time -- see
+    # `core_runtime._corr_shaded_positions`.  The names cannot be resolved here
+    # because `order` has already moved them.
+    shaded_positions = kwargs.pop("__corr_shaded__", None)
+    if stripe == "selected" and shaded_positions is None:
         raise ValueError(
-            "corrplot stripe must be alternate or none; got {!r}.".format(stripe)
+            "corrplot stripe: selected needs stripe.variables -- the names to "
+            "tint. Without them the tint would say nothing."
         )
     stripe_color = _pop(kwargs, "stripe.col", "#EFEFEF")
     # Diamond only.  See `_edge_rules`: the rotated matrix has no top or bottom
@@ -883,7 +911,7 @@ def draw_corrplot(ax, **kwargs):
                 edge_color, clip, zorder + 40,
             )
 
-    if diamond and stripe == "alternate" and np.any(drawn):
+    if diamond and stripe != "none" and np.any(drawn):
         # Every other variable's cells, tinted.  Not decoration: a variable's
         # pairs run away from its name as a V, and at 40 names a reader
         # following one of those arms has nothing to hold on to.  The band is
@@ -899,7 +927,7 @@ def draw_corrplot(ax, **kwargs):
         #
         # The union of those variables' cells rather than one band each, so a
         # cell where two bands cross is filled once and the tint stays even.
-        shaded = _shaded_variables(n, blocks)
+        shaded = _shaded_variables(n, blocks, shaded_positions)
         band = shaded[index_x.astype(int)] | shaded[index_y.astype(int)]
         band &= drawn
         if np.any(band):
@@ -1091,7 +1119,7 @@ def draw_corrplot(ax, **kwargs):
     # block above), so a box around each of them would be the same fact drawn
     # twice, in the heaviest ink on the figure.  `addrect` still decides *what*
     # the blocks are; it just stops drawing them.
-    if blocks and not (diamond and stripe != "none"):
+    if blocks and not (diamond and stripe == "alternate"):
         for start, end in blocks:
             if diamond:
                 ax.add_patch(

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/Figure/layout_runtime.py

@@ -533,15 +533,35 @@ def apply_manual_ticks(fig, ax_obj, which: str, ticks_cfg: dict):
     if pos is None:
         return
     target = ax_obj.ax if hasattr(ax_obj, "ax") else ax_obj
+
+    # Matplotlib's set_xticks/set_yticks expands the view limits when a
+    # requested tick lies outside the current range.  That is surprising for
+    # Jarvis-PLOT cards, where an explicit frame.xlim/ylim is authoritative
+    # (e.g. ylim: [200, 400] with a stale tick at 600).  Preserve the range
+    # only when autoscaling was already disabled; otherwise leave the normal
+    # autoscaling behaviour untouched for axes whose limits are data-driven.
+    axis = str(which).lower()
+    if axis not in {"x", "y"}:
+        return
+    get_lim = target.get_xlim if axis == "x" else target.get_ylim
+    set_lim = target.set_xlim if axis == "x" else target.set_ylim
+    get_autoscale = (
+        target.get_autoscalex_on if axis == "x" else target.get_autoscaley_on
+    )
+    original_lim = get_lim()
+    autoscale_was_on = get_autoscale()
     try:
-        if which == "x":
+        if axis == "x":
             target.set_xticks(pos)
             if labs is not None:
                 target.set_xticklabels(labs)
-        elif which == "y":
+        elif axis == "y":
             target.set_yticks(pos)
             if labs is not None:
                 target.set_yticklabels(labs)
     except Exception as e:
         if fig.logger:
             fig.logger.warning(f"Manual ticks apply failed on {which}-axis: {e}")
+    finally:
+        if not autoscale_was_on:
+            set_lim(original_lim)

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/Figure/preprocessor.py

@@ -851,7 +851,7 @@ class DataPreprocessor:
         eff_transform = self._effective_transform(source, transform)
         payload = {
             "kind": "pipeline",
-            "algo": "pregrid-v6",
+            "algo": "pregrid-v7-objective-finite-voronoi",
             "source": self._source_token(source, combine=combine),
             "transform": eff_transform,
             "combine": str(combine),
@@ -900,12 +900,11 @@ class DataPreprocessor:
             if isinstance(item, Mapping):
                 src = item.get("source")
                 tf = self._effective_transform(src, item.get("transform"))
-                tokens.append(
-                    {
-                        "source": self._source_token(src),
-                        "transform": tf,
-                    }
-                )
+                token = {"source": self._source_token(src), "transform": tf}
+                profile_sig = self._runtime_profile_signature(tf)
+                if profile_sig is not None:
+                    token["profile_signature"] = profile_sig
+                tokens.append(token)
         payload = {
             "name": layer.get("name"),
             "axes": layer.get("axes"),
@@ -928,7 +927,7 @@ class DataPreprocessor:
                     cfg = deepcopy(cfg)
                 else:
                     cfg = {"value": cfg}
-                tokens.append({"kind": "profile", "cfg": cfg})
+                tokens.append({"kind": "profile", "algo": "objective-finite-voronoi-v2", "cfg": cfg})
         return tokens
 
     def _runtime_profile_signature(self, transform: Any) -> Optional[str]:
@@ -1332,13 +1331,17 @@ class DataPreprocessor:
 
     @staticmethod
     def _preprofile_profile_cfg(profile_cfg: Any) -> Any:
-        # Preprofile cache identity is intentionally coordinates-only:
-        # runtime profile method/bin/objective changes must reuse same preprofile.
+        # Runtime method/bin can share a preprofile, but objective and pregrid
+        # controls change which source rows survive and must enter its identity.
         if not isinstance(profile_cfg, Mapping):
             return {}
         slim: Dict[str, Any] = {}
         if "coordinates" in profile_cfg:
             slim["coordinates"] = deepcopy(profile_cfg["coordinates"])
+        slim["objective"] = str(profile_cfg.get("objective", "max")).lower()
+        for key in ("pregrid", "pregrid_bin"):
+            if key in profile_cfg:
+                slim[key] = deepcopy(profile_cfg[key])
         return slim
 
     def _split_prebuild_transform(self, transform: Any):

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/Figure/profile_runtime.py

@@ -451,11 +451,26 @@ def profiling(df, prof, logger):
     else:
         z = df["z"]
 
-    logger.debug("After loading profiling x, y, z. ")
+    if logger:
+        logger.debug("After loading profiling x, y, z. ")
 
-    x = np.asarray(x)
-    y = np.asarray(y)
-    z = np.asarray(z)
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    z = np.asarray(z, dtype=float)
+    # A single invalid objective used to poison min/max(z), making every
+    # normalized dz NaN and silently disabling the z-aware exclusion rule.
+    valid = np.isfinite(x) & np.isfinite(y) & np.isfinite(z)
+    for cfg, values in ((xcfg, x), (ycfg, y), (zcfg, z)):
+        if str(cfg.get("scale", "linear")).lower() == "log":
+            valid &= values > 0
+    if not np.all(valid):
+        df = df.iloc[np.flatnonzero(valid)]
+        x, y, z = x[valid], y[valid], z[valid]
+    if not len(z):
+        out = df.copy()
+        for cfg, values, default in ((xcfg, x, "x"), (ycfg, y, "y"), (zcfg, z, "z")):
+            out[cfg.get("name", default)] = values
+        return out
 
     if grid == "ternary":
         xlim = xcfg.get("lim", [0, 1])
@@ -535,20 +550,12 @@ def profiling(df, prof, logger):
         },
     )
 
-    if xscale == "log":
-        xx = (np.log(xx) - np.log(xlim[0])) / (np.log(xlim[1]) - np.log(xlim[0]))
-    else:
-        xx = (xx - xlim[0]) / (xlim[1] - xlim[0])
-
-    if yscale == "log":
-        yy = (np.log(yy) - np.log(ylim[0])) / (np.log(ylim[1]) - np.log(ylim[0]))
-    else:
-        yy = (yy - ylim[0]) / (ylim[1] - ylim[0])
-
-    if zscale == "log":
-        zz = (np.log(zz) - np.log(zlim[0])) / (np.log(zlim[1]) - np.log(zlim[0]))
-    else:
-        zz = (zz - zlim[0]) / (zlim[1] - zlim[0])
+    xx = _normalize_profile_axis(xx, xlim, xscale)
+    yy = _normalize_profile_axis(yy, ylim, yscale)
+    zz = _normalize_profile_axis(zz, zlim, zscale)
+    # Empty-grid seeds are processed last and carry NaN in the output. Give
+    # them a finite exclusion coordinate, including for logarithmic z.
+    zz[len(order):] = 2.0 if obj == "min" else -1.0
 
     msk = profile_bridson_sorted(xx, yy, zz, radius)
     keep_pos = np.flatnonzero(msk).astype(np.int64, copy=False)
@@ -557,6 +564,22 @@ def profiling(df, prof, logger):
     keep_source = keep_pos[keep_pos < source_count]
     keep_grid = keep_pos[keep_pos >= source_count] - source_count
 
+    # Greedy thinning only chooses the spatial partition: a high-valued point
+    # can be suppressed by an earlier seed, then a worse seed can survive on
+    # the other side of it. Re-profile *all* input rows within the nearest-seed
+    # (Voronoi) cells so those suppressed candidates still contribute. Select
+    # the entire winning source row, not just its z at another row's x/y.
+    if keep_source.size:
+        from scipy.spatial import cKDTree
+
+        source_xy = np.column_stack([xx[:source_count], yy[:source_count]])
+        tree = cKDTree(source_xy[keep_source])
+        _, cell = tree.query(source_xy)
+        winners = np.full(keep_source.size, source_count, dtype=np.int64)
+        # Input is already ordered best first for either max or min.
+        np.minimum.at(winners, cell, np.arange(source_count, dtype=np.int64))
+        keep_source = np.sort(winners[winners < source_count])
+
     source_rows = order[keep_source]
     source_x = x[source_rows]
     source_y = y[source_rows]
@@ -594,7 +617,7 @@ def profiling(df, prof, logger):
 
 
 def _preprofiling(df, prof, logger):
-    """Lightweight pre-profiling for cache prebuild."""
+    """Keep the requested finite extremum per pre-bin for cache prebuild."""
 
     def _norm(arr, lim, scale):
         arr = np.asarray(arr, dtype=float)
@@ -765,14 +788,14 @@ def _preprofiling(df, prof, logger):
 
     xnorm = _norm(xvals, xlim, xscale)
     ynorm = _norm(yvals, ylim, yscale)
-    valid = np.isfinite(xnorm) & np.isfinite(ynorm)
+    valid = np.isfinite(xnorm) & np.isfinite(ynorm) & np.isfinite(zvals)
     if not np.any(valid):
         if logger:
-            logger.warning("Preprofiling got no finite points; returning original dataframe.")
-        out = df.copy(deep=False)
-        out[xind] = xvals
-        out[yind] = yvals
-        out[zind] = zvals
+            logger.warning("Preprofiling got no finite points; returning an empty dataframe.")
+        out = df.iloc[:0].copy()
+        out[xind] = xvals[:0]
+        out[yind] = yvals[:0]
+        out[zind] = zvals[:0]
         return out
 
     xv = np.clip(xnorm[valid], 0.0, 1.0 - 1e-12)
@@ -783,20 +806,19 @@ def _preprofiling(df, prof, logger):
 
     idx_src = np.flatnonzero(valid).astype(np.int64)
     zraw = np.asarray(zvals, dtype=float)[valid]
-    zmax = np.where(np.isfinite(zraw), zraw, -np.inf)
-    zmin = np.where(np.isfinite(zraw), zraw, np.inf)
     tmp = pd.DataFrame(
         {
             "__cell__": cell,
-            "__zmax__": zmax,
-            "__zmin__": zmin,
+            "__z__": zraw,
             "__pos__": idx_src,
         }
     )
 
-    loc_max = tmp.groupby("__cell__", sort=False)["__zmax__"].idxmax().to_numpy(dtype=np.int64, copy=False)
-    loc_min = tmp.groupby("__cell__", sort=False)["__zmin__"].idxmin().to_numpy(dtype=np.int64, copy=False)
-    loc_all = np.unique(np.concatenate([loc_max, loc_min], axis=0))
+    if str(prof.get("objective", "max")).lower() == "min":
+        loc = tmp.groupby("__cell__", sort=False)["__z__"].idxmin()
+    else:
+        loc = tmp.groupby("__cell__", sort=False)["__z__"].idxmax()
+    loc_all = np.sort(loc.to_numpy(dtype=np.int64, copy=False))
     keep_pos = tmp.iloc[loc_all]["__pos__"].to_numpy(dtype=np.int64, copy=False)
     reduced = df.iloc[keep_pos].copy()
     reduced[xind] = xvals[keep_pos]

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/cards/colors/colormaps.json

@@ -95,6 +95,21 @@
 				[1.0, "#575AA6"]
       ]
     },
+    {
+      "name": "Jpurples",
+      "type": "linear",
+      "colors": [
+        [0.000, "#FFFFFF"],
+        [0.125, "#EFEDF5"],
+        [0.250, "#DADAEB"],
+        [0.375, "#BCBDDC"],
+        [0.500, "#9E9AC8"],
+        [0.625, "#807CBA"],
+        [0.750, "#6950A3"],
+        [0.875, "#53268F"],
+        [1.000, "#3F007D"]
+      ]
+    },
     {
       "name": "SpectralB",
       "type": "linear",

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/cards/corrplot/diamond.json

@@ -498,7 +498,8 @@
         "type": {"type": "enum", "values": ["upper", "lower"], "default": "upper", "forbidden": ["full"]},
         "diag": {"type": "boolean", "default": true},
         "side": {"type": "enum", "values": ["left", "right"], "default": "right"},
-        "stripe": {"type": "enum", "values": ["alternate", "none"], "default": "alternate", "false_alias": "none"},
+        "stripe": {"type": "enum", "values": ["alternate", "selected", "none"], "default": "alternate", "false_alias": "none"},
+        "stripe.variables": {"type": "list_of_strings", "default": null, "requires": {"stripe": "selected"}},
         "order": {"type": "enum", "values": ["original", "AOE", "FPC", "hclust", "alphabet"], "default": "original"},
         "hclust.method": {"type": "enum", "values": ["single", "complete", "average", "weighted", "mcquitty", "median", "centroid", "ward.D", "ward.D2"], "default": "complete"},
         "addrect": {"type": "integer_or_null", "default": null, "requires": {"order": "hclust"}},

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/core_runtime.py

@@ -590,6 +590,47 @@ def _solve_corr_diamond(card, info, style, columns, axes_name):
     return geom, solved
 
 
+def _corr_shaded_positions(style: Mapping, columns, name: str):
+    """`stripe.variables` resolved against the order the figure ended up in.
+
+    It has to happen here and not at draw time.  The renderer sees positions,
+    and which position a variable holds is `order`'s answer, settled a moment
+    ago -- a name resolved against the *unordered* columns would tint a
+    different variable on every reordering and never say so.
+
+    A name that is not in the matrix is an error rather than a silent miss, for
+    the same reason: a tint that quietly did nothing is indistinguishable from
+    a tint that was not asked for.
+    """
+    stripe = style.get("stripe", "alternate")
+    stripe = "none" if stripe is False else str(stripe or "").strip().lower()
+    wanted = style.get("stripe.variables")
+    if wanted is None:
+        return None
+    if stripe != "selected":
+        raise ValueError(
+            "figure '{}' gives corrplot stripe.variables with stripe: {}. The "
+            "names are only read by stripe: selected; leaving them here would "
+            "draw the other tint and say nothing about them.".format(name, stripe)
+        )
+    if isinstance(wanted, str) or not isinstance(wanted, (list, tuple, set)):
+        raise ValueError(
+            "figure '{}' gives corrplot stripe.variables: {!r}. It takes a "
+            "list of variable names.".format(name, wanted)
+        )
+    at = {str(column): position for position, column in enumerate(columns)}
+    missing = [str(v) for v in wanted if str(v) not in at]
+    if missing:
+        raise ValueError(
+            "figure '{}' asks corrplot to tint {}, which {} not in the matrix. "
+            "The variables drawn are: {}.".format(
+                name, ", ".join(missing), "is" if len(missing) == 1 else "are",
+                ", ".join(str(c) for c in columns),
+            )
+        )
+    return sorted(at[str(v)] for v in wanted)
+
+
 def _as_corr_bool(value, default: bool = False) -> bool:
     if value is None:
         return default
@@ -1000,6 +1041,11 @@ def _prebuild_one(core, info: dict, card: Mapping) -> None:
         # but placed and sized by the solve.
         layer["style"]["__corr_number_mm__"] = geom.number_pad_mm
         layer["style"]["__corr_number_pt__"] = geom.number_size_pt
+        # `stripe.variables` names variables; the renderer draws positions, and
+        # only the order settled above knows which is which.
+        shaded = _corr_shaded_positions(style, columns, info.get("name", "?"))
+        if shaded is not None:
+            layer["style"]["__corr_shaded__"] = shaded
 
     if blocks:
         # The boxes are cuts of the tree the order came from, so they are

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/manual_cards/method_notes.yaml

@@ -62,7 +62,7 @@ corrplot:
     - "Reserved: only the [corrplot, matrix] or [corrplot, diamond] style card provides its axes (axcorr / axccorr)."
     - "No coordinates needed — x_index / y_index / rho are the transform's own output columns."
     - "style takes R's formals: method (circle|square|ellipse|color|shade|pie|number), type, diag, glyph.scale, outline, addgrid.col, plus the card's own ellipse.scale."
-    - "Use [corrplot, matrix] for the square matrix; [corrplot, diamond] keeps one triangle, rotates it 45 degrees, and adds side: left|right (default right, which puts the triangle on the left of the page) plus stripe: alternate|none."
+    - "Use [corrplot, matrix] for the square matrix; [corrplot, diamond] keeps one triangle, rotates it 45 degrees, and adds side: left|right (default right, which puts the triangle on the left of the page) plus stripe: alternate|selected|none. stripe: selected takes the variables to tint in stripe.variables, resolved against the solved order; diag: true|false is the self-correlation on the diagonal, on by default."
     - "order (original|AOE|FPC|hclust|alphabet) and addrect are resolved before the figure is built, then written into the transform's `columns`."
     - "sig.level switches on the significance test; unlike R no p.mat is needed, because the table carries n per pair."
     - "The glyph is sized from the solved cell and the coefficient text is back-solved from it, so both survive the 170 mm width clamp."

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/manual_cards/type-correlation-matrix.yaml

@@ -45,7 +45,9 @@ human:
         `style: [corrplot, diamond]` picks the other card: the same matrix as
         one triangle turned 45 degrees, names in a plain column of horizontal
         text, each variable's pairs a V rooted at its own name. Same formals,
-        plus `side: left | right` (default `right`, the triangle on the left of the page) and `stripe: alternate | none`.
+        plus `side: left | right` (default `right`, the triangle on the left of the page) and `stripe: alternate | selected | none`
+        (`selected` names the variables in `stripe.variables`), plus
+        `diag: true | false` for the self-correlation on the diagonal.
     - kind: yaml
       title: Minimal figure
       lexer: yaml

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/transform_contracts.py

@@ -499,7 +499,8 @@ TRANSFORM_CONTRACTS: dict[str, dict[str, Any]] = {
                 "description": (
                     "Optional coarse pre-binning before Bridson/grid profile "
                     "(large tables). Mapping: {bin, enable}; false disables; "
-                    "omit for auto-prebin from row count."
+                    "omit for auto-prebin from row count. Keeps one finite "
+                    "extremum per cell according to objective (max/min)."
                 ),
                 "properties": {
                     "bin": {

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/utils/cmaps.py

@@ -40,7 +40,9 @@ def _register(name: str, cmap: Colormap, force: bool) -> bool:
                         cmap.name = name
                     except Exception:
                         pass
-                if "override" in sig.parameters:
+                if "force" in sig.parameters:
+                    kwargs["force"] = bool(force)
+                elif "override" in sig.parameters:
                     kwargs["override"] = bool(force)
             except Exception:
                 # If signature introspection fails, try safest call (cmap only).

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/jarvisplot/verbs/cap.py

@@ -170,6 +170,7 @@ _CMAP_DESCRIPTIONS = {
     "gambit_cmap": "Continuous black → blue → cyan → yellow map.",
     "jarvis_rainbow": "Continuous purple → blue → cyan → green → orange → red map.",
     "jarvis_rainbow2": "Continuous red → yellow → green → blue map.",
+    "Jpurples": "Matplotlib Purples-style continuous map with a pure-white zero endpoint.",
     "SpectralB": "Spectral-style continuous map from red through green to blue.",
     "RdBuB": "Diverging red → white → blue map.",
     "chrisB": "Diverging black → red → white → blue → navy map.",

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "JarvisPLOT"
-version = "2.1.2"
+version = "2.1.4"
 description = "Jarvis-PLOT: YAML-driven plotting engine"
 readme = "README.md"
 requires-python = ">=3.10"

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/tests/test_axis_title.py

@@ -257,3 +257,29 @@ def test_side_axes_honour_manual_tick_positions():
         assert [t.get_text() for t in ax.ax.get_yticklabels()] == list("abcde")
     finally:
         plt.close(raw_fig)
+
+
+def test_manual_ticks_do_not_expand_explicit_axis_limits():
+    """Out-of-range manual ticks must not override an explicit frame limit."""
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    from jarvisplot.Figure.layout_runtime import apply_manual_ticks
+
+    raw_fig, ax = plt.subplots(figsize=(3.3, 3.0))
+    ax.set_ylim(200, 400)
+    apply_manual_ticks(
+        SimpleNamespace(logger=_logger()),
+        ax,
+        "y",
+        {
+            "positions": [200, 300, 400, 500, 600],
+            "labels": ["200", "300", "400", "500", "600"],
+        },
+    )
+
+    assert ax.get_ylim() == pytest.approx((200.0, 400.0))
+    assert list(ax.get_yticks()) == [200, 300, 400, 500, 600]
+    plt.close(raw_fig)

{jarvisplot-2.1.2 → jarvisplot-2.1.4}/tests/test_cmaps.py

@@ -4,6 +4,7 @@ import json
 from pathlib import Path
 
 import matplotlib as mpl
+import numpy as np
 
 from jarvisplot.utils import cmaps
 
@@ -40,3 +41,17 @@ def test_official_tab5_is_registered_as_five_discrete_tab10_colors():
     )
     assert spec["type"] == "listed"
     assert len(spec["colors"]) == 5
+
+
+def test_jpurples_matches_purples_style_with_a_pure_white_zero_endpoint():
+    summary = cmaps.register_from_json(COLORMAPS_JSON, force=True)
+
+    assert "Jpurples" in summary["registered"]
+    assert "Jpurples_r" in summary["registered"]
+
+    jpurples = mpl.colormaps["Jpurples"]
+    purples = mpl.colormaps["Purples"]
+
+    assert mpl.colors.to_hex(jpurples(0.0), keep_alpha=False) == "#ffffff"
+    for value in (0.125, 0.25, 0.5, 0.75, 1.0):
+        assert np.allclose(jpurples(value), purples(value), atol=1 / 255)