jarvisplot 2.1.3__tar.gz → 2.1.4__tar.gz

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

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

{jarvisplot-2.1.3 → 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.3 → jarvisplot-2.1.4}/PKG-INFO

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

{jarvisplot-2.1.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → jarvisplot-2.1.4}/pyproject.toml

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

{jarvisplot-2.1.3 → 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.3 → 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)

{jarvisplot-2.1.3 → jarvisplot-2.1.4}/tests/test_figure_contracts.py

@@ -1094,10 +1094,12 @@ def test_preprofile_identity_ignores_runtime_bin():
         "coordinates": {"x": {"expr": "x"}, "y": {"expr": "y"}},
         "method": "bridson",
         "bin": 32,
-        "objective": "min",
+        "objective": "max",
     }
 
     assert dp._preprofile_profile_cfg(cfg1) == dp._preprofile_profile_cfg(cfg2)
+    cfg2["objective"] = "min"
+    assert dp._preprofile_profile_cfg(cfg1) != dp._preprofile_profile_cfg(cfg2)
 
 
 def test_runtime_projection_includes_row_identity_and_demand():
@@ -1159,7 +1161,7 @@ def test_runtime_transform_to_csv_exports_and_bypasses_cache(tmp_path):
     assert list(out.columns) == ["y", "z"]
 
 
-def test_prebuild_split_keeps_profile_identity_coordinates_only():
+def test_prebuild_split_keeps_profile_reduction_controls():
     dp = DataPreprocessor(context=None)
     transform = [
         {"add_column": {"name": "c", "expr": "a + b"}},
@@ -1169,6 +1171,7 @@ def test_prebuild_split_keeps_profile_identity_coordinates_only():
                 "method": "bridson",
                 "bin": 16,
                 "objective": "max",
+                "pregrid": {"bin": 25, "enable": True},
             }
         },
         {"sortby": "c"},
@@ -1178,7 +1181,11 @@ def test_prebuild_split_keeps_profile_identity_coordinates_only():
 
     assert pre_transform is not None
     assert runtime_transform is not None
-    assert pre_transform[-1]["profile"] == {"coordinates": {"x": {"expr": "x"}, "y": {"expr": "y"}}}
+    assert pre_transform[-1]["profile"] == {
+        "coordinates": {"x": {"expr": "x"}, "y": {"expr": "y"}},
+        "objective": "max",
+        "pregrid": {"bin": 25, "enable": True},
+    }
     assert runtime_transform[0]["profile"]["method"] == "bridson"
     assert runtime_transform[0]["profile"]["bin"] == 16
     assert runtime_transform[1]["sortby"] == "c"

jarvisplot-2.1.4/tests/test_profile_runtime.py

@@ -0,0 +1,141 @@
+"""Regression coverage for finite, objective-aware profile support selection."""
+
+import logging
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from jarvisplot.Figure.preprocessor import DataPreprocessor
+from jarvisplot.Figure.data_pipelines import DataContext, SharedContent
+from jarvisplot.Figure.profile_runtime import _preprofiling, profiling
+from jarvisplot.cache_store import ProjectCache
+
+
+def config(objective="max"):
+    return {
+        "method": "bridson", "bin": 100, "objective": objective,
+        "grid_points": "none", "pregrid": {"bin": 10},
+        "coordinates": {
+            k: {"expr": k, "name": k, "lim": [0, 1]}
+            for k in ("x", "y")
+        } | {"z": {"expr": "z", "name": "z"}},
+    }
+
+
+@pytest.mark.parametrize("objective,expected", [("max", [1.0, 0.8]), ("min", [0.0, 0.2])])
+def test_preprofile_keeps_only_requested_extremum(objective, expected):
+    # Duplicate dataframe indices occur when scan files are concatenated.
+    df = pd.DataFrame({
+        "x": [0.11, 0.12, 0.41, 0.42, 0.8],
+        "y": [0.11, 0.12, 0.41, 0.42, 0.8],
+        "z": [0.0, 1.0, 0.2, 0.8, np.nan],
+        "row": ["low1", "high1", "low2", "high2", "invalid"],
+    }, index=[0, 1, 0, 1, 0])
+    out = _preprofiling(df, config(objective), None)
+    np.testing.assert_allclose(out.z, expected)
+    assert out.row.tolist() == (["high1", "high2"] if objective == "max" else ["low1", "low2"])
+
+
+@pytest.mark.parametrize("objective", ["max", "min"])
+def test_invalid_objective_does_not_disable_bridson_exclusion(objective):
+    # The inferior point lies in the annulus where z-aware rejection is needed.
+    z = [1.0, 0.0] if objective == "max" else [0.0, 1.0]
+    good = pd.DataFrame({"x": [0.1, 0.109], "y": [0.1, 0.1], "z": z})
+    dirty = pd.concat([good, pd.DataFrame({
+        "x": [0.8, 0.9, 0.7], "y": [0.8, 0.9, 0.7],
+        "z": [np.nan, np.inf, -np.inf],
+    })], ignore_index=True)
+    log = logging.getLogger(__name__)
+    expected = profiling(good, config(objective), log)
+    actual = profiling(dirty, config(objective), log)
+    assert len(actual) == 1
+    pd.testing.assert_frame_equal(actual, expected)
+
+
+def test_constant_profile_still_thins_close_points():
+    df = pd.DataFrame({"x": [0.1, 0.101], "y": [0.1, 0.1], "z": [0.0, 0.0]})
+    with np.errstate(invalid="raise", divide="raise"):
+        out = profiling(df, config(), None)
+    assert len(out) == 1
+    assert out.z.iloc[0] == 0.0
+
+
+@pytest.mark.parametrize("objective", ["max", "min"])
+def test_suppressed_candidate_still_contributes_to_cell_extremum(objective):
+    # A suppresses B, but C lies outside A's exclusion radius. B belongs to
+    # C's nearest-seed cell and is better than C: thinning alone leaks C.
+    df = pd.DataFrame({
+        "x": [0.1, 0.1092, 0.1179], "y": [0.1, 0.1, 0.1],
+        "z": [1.0, 0.9, 0.0] if objective == "max" else [0.0, 0.1, 1.0],
+        "row": ["A", "B", "C"], "nuisance": [10.0, 20.0, 30.0],
+    })
+    actual = profiling(df, config(objective), None)
+    assert actual.row.tolist() == ["A", "B"]
+    pd.testing.assert_frame_equal(actual.reset_index(drop=True), df.iloc[:2].reset_index(drop=True))
+
+
+def test_all_invalid_profile_returns_empty_named_columns():
+    df = pd.DataFrame({"x": [0.1], "y": [0.1], "z": [np.nan]})
+    cfg = config()
+    cfg["coordinates"]["z"]["name"] = "likelihood"
+    for reduce in (_preprofiling, profiling):
+        out = reduce(df, cfg, None)
+        assert out.empty
+        assert "likelihood" in out
+
+
+def test_log_profile_ignores_nonpositive_coordinates_and_constant_z():
+    cfg = config()
+    cfg["grid_points"] = "rect"
+    cfg["bin"] = 4
+    for key in ("x", "y", "z"):
+        cfg["coordinates"][key]["scale"] = "log"
+    for key in ("x", "y"):
+        cfg["coordinates"][key]["lim"] = [1, 10]
+    df = pd.DataFrame({"x": [2.0, 0.0, -1.0], "y": [3.0, 3.0, 3.0], "z": [0.05, 0.05, 0.05]})
+    with np.errstate(invalid="raise", divide="raise"):
+        out = profiling(df, cfg, None)
+    actual = out[np.isfinite(out.z)]
+    assert actual.x.tolist() == [2.0]
+    assert actual.z.tolist() == [0.05]
+
+
+def test_pregrid_controls_and_objective_change_cache_identity():
+    dp = DataPreprocessor(context=None)
+    cfg = config()
+    base = dp._preprofile_profile_cfg(cfg)
+    for change in ({"objective": "min"}, {"pregrid": False}, {"pregrid": {"bin": 20}}, {"pregrid_bin": 20}):
+        other = dp._preprofile_profile_cfg(cfg | change)
+        assert dp._pipeline_key("scan", [{"profile": base}], mode="preprofile") != dp._pipeline_key(
+            "scan", [{"profile": other}], mode="preprofile"
+        )
+    pre, _ = dp._split_prebuild_transform([{"profile": cfg | {"pregrid": False}}])
+    df = pd.DataFrame({"x": [0.11, 0.12], "y": [0.11, 0.12], "z": [0.0, 1.0]})
+    assert _preprofiling(df, pre[0]["profile"], None) is df
+
+
+def test_old_named_profile_signature_is_invalidated(monkeypatch):
+    dp = DataPreprocessor(context=None)
+    layer = {"name": "support", "data": [{"source": "scan", "transform": [{"profile": config()}]}]}
+    current = dp._layer_signature(layer)
+    monkeypatch.setattr(dp, "_runtime_profile_signature", lambda tf: "old-algorithm")
+    assert dp._layer_signature(layer) != current
+
+
+def test_prebuild_cached_max_and_min_do_not_reuse_each_others_rows(tmp_path):
+    df = pd.DataFrame({"x": [0.11, 0.12], "y": [0.11, 0.12], "z": [0.0, 1.0]})
+    for warm in (False, True):
+        ctx = DataContext(SharedContent())
+        ctx.register("scan", lambda _: df)
+        dp = DataPreprocessor(ctx, cache=ProjectCache(str(tmp_path)))
+        project = {"Figures": [{"name": "test", "layers": [
+            {"name": objective, "data": [{"source": "scan", "transform": [{"profile": config(objective)}]}]}
+            for objective in ("max", "min")
+        ]}]}
+        stats = dp.prebuild_profiles(project)
+        assert stats["hits"] == (2 if warm else 0)
+        entries = [layer["data"][0] for layer in project["Figures"][0]["layers"]]
+        assert entries[0]["source"] != entries[1]["source"]
+        assert ctx.get(entries[0]["source"]).z.tolist() == [1.0]
+        assert ctx.get(entries[1]["source"]).z.tolist() == [0.0]