jarvisplot 2.1.4__tar.gz → 2.1.5__tar.gz

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

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

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

@@ -22,6 +22,7 @@ jarvisplot/core.py
 jarvisplot/core_assets.py
 jarvisplot/core_runtime.py
 jarvisplot/data_access.py
+jarvisplot/data_generation_contracts.py
 jarvisplot/data_loader.py
 jarvisplot/data_loader_hdf5.py
 jarvisplot/data_loader_runtime.py
@@ -33,6 +34,7 @@ jarvisplot/dryrun_runtime.py
 jarvisplot/expr_names.py
 jarvisplot/fix_apply.py
 jarvisplot/flowchart.py
+jarvisplot/generated_data.py
 jarvisplot/inner_func.py
 jarvisplot/man_catalog.py
 jarvisplot/man_methods.py
@@ -121,6 +123,8 @@ jarvisplot/manual_cards/data-columns.yaml
 jarvisplot/manual_cards/debug-overlay.yaml
 jarvisplot/manual_cards/diagnostics.yaml
 jarvisplot/manual_cards/dryrun-viz.yaml
+jarvisplot/manual_cards/field-interp.yaml
+jarvisplot/manual_cards/generated-data.yaml
 jarvisplot/manual_cards/layer-method.yaml
 jarvisplot/manual_cards/manifest.yaml
 jarvisplot/manual_cards/method_notes.yaml
@@ -136,6 +140,7 @@ jarvisplot/schema/plot-config.json
 jarvisplot/schema/core/common.json
 jarvisplot/schema/core/dataset.json
 jarvisplot/schema/core/figure.json
+jarvisplot/schema/core/generated-data.json
 jarvisplot/schema/core/layer.json
 jarvisplot/schema/core/transform.json
 jarvisplot/schema/methods/bar.json
@@ -217,6 +222,7 @@ tests/test_figure_contracts.py
 tests/test_figure_type_expander.py
 tests/test_fix_application.py
 tests/test_flowchart_renderer.py
+tests/test_generated_data.py
 tests/test_imshow_adapter.py
 tests/test_interp_2d_transform.py
 tests/test_interp_natural_neighbor.py

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

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

{jarvisplot-2.1.4 → jarvisplot-2.1.5}/jarvisplot/Figure/adapters_rect.py

@@ -12,7 +12,11 @@ from matplotlib.collections import PolyCollection
 #
 from .helper import _auto_clip, _mask_by_extend, voronoi_finite_polygons_2d, _clip_poly_to_rect
 from .profile_runtime import grid_from_metadata, regular_grid_mesh
-from .interp_natural_neighbor import resolve_backend
+from .interp_natural_neighbor import (
+    drawing_backend_options,
+    log_backend_diagnostics,
+    resolve_backend,
+)
 from .posterior_hpd import prepare_hpd_contour_style
 
 DEFAULT_JP_SAMPLE_GRID = 500
@@ -242,8 +246,9 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         backend_options: Optional[dict[str, Any]] = None,
+        logger=None,
     ):
         x = np.asarray(x, dtype=float).reshape(-1)
         y = np.asarray(y, dtype=float).reshape(-1)
@@ -273,8 +278,9 @@ class StdAxesAdapter:
             X,
             Y,
             nan_policy=nan_policy,
-            backend_options=backend_options,
+            backend_options=drawing_backend_options(backend_options),
         )
+        log_backend_diagnostics(logger, getattr(backend, "last_diagnostics", None))
         return X, Y, np.asarray(Z, dtype=float)
 
     def _build_jpcontour_grid(
@@ -322,9 +328,10 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
+        logger=None,
     ):
         """Interpolate scattered data on an axes-fraction grid for contour rendering.
 
@@ -361,8 +368,9 @@ class StdAxesAdapter:
             Y,
             nan_policy=nan_policy,
             diagnostics=diagnostics,
-            backend_options=backend_options,
+            backend_options=drawing_backend_options(backend_options),
         )
+        log_backend_diagnostics(logger, getattr(backend, "last_diagnostics", None))
         return X, Y, np.asarray(Z, dtype=float)
 
     # —— Common method forwarding (add as needed) ——
@@ -518,12 +526,18 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
         **kwargs,
     ):
-        """Scattered-data contour plot rendered in axes-fraction coordinates."""
+        """Scattered-data contour plot rendered in axes-fraction coordinates.
+
+        ``nan_policy`` defaults to ``ignore`` here: a sample whose z is NaN --
+        an empty profile-likelihood cell, say -- is not a measurement, and
+        letting it propagate would blank the cells around it as well. Pass
+        ``nan_policy="strict"`` to keep those neighbourhoods masked instead.
+        """
         kw = self._merge("contour", kwargs)
         kw.pop("transform", None)
         logger = kw.pop("_logger", None)
@@ -540,6 +554,7 @@ class StdAxesAdapter:
             nan_policy=nan_policy,
             diagnostics=diagnostics,
             backend_options=backend_options,
+            logger=logger,
         )
         kw = prepare_hpd_contour_style(Z, X, Y, kw, logger=logger)
         label_map = kw.pop("_hpd_label_map", None)
@@ -570,7 +585,7 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
         **kwargs,
@@ -578,6 +593,7 @@ class StdAxesAdapter:
         """Filled scattered-data contour plot rendered in axes-fraction coordinates."""
         kw = self._merge("contourf", kwargs)
         kw.pop("transform", None)
+        logger = kw.pop("_logger", None)
         X, Y, Z = self._interpolate_jpcontour_grid(
             x,
             y,
@@ -591,6 +607,7 @@ class StdAxesAdapter:
             nan_policy=nan_policy,
             diagnostics=diagnostics,
             backend_options=backend_options,
+            logger=logger,
         )
         artists = self.ax.contourf(
             X,
@@ -614,7 +631,7 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         backend_options: Optional[dict[str, Any]] = None,
         shading: str = "auto",
         **kwargs,
@@ -633,6 +650,7 @@ class StdAxesAdapter:
             kw.pop(k, None)
         kw.pop("shading", None)
         kw.pop("transform", None)
+        logger = kw.pop("_logger", None)
         X, Y, Z = self._interpolate_jpfield_grid(
             x,
             y,
@@ -645,6 +663,7 @@ class StdAxesAdapter:
             ylim=ylim,
             nan_policy=nan_policy,
             backend_options=backend_options,
+            logger=logger,
         )
         X = np.asarray(X, dtype=float)
         Y = np.asarray(Y, dtype=float)

{jarvisplot-2.1.4 → jarvisplot-2.1.5}/jarvisplot/Figure/design_runtime.py

@@ -129,8 +129,12 @@ def _preview_colorbar(fig, name, cfg):
 
     from .colorbar_runtime import axc_color_config, axc_is_horizontal
 
-    cmap = axc_color_config(fig.frame, name).get("cmap") or cfg["fallback_cmap"]
-    is_h = axc_is_horizontal(fig.frame, name)
+    # Lightweight wrappers used by design tooling may expose only ``fig`` and
+    # ``axes``. An absent frame means there is no colorbar override, not that
+    # the rest of the debug overlay should be abandoned halfway through.
+    frame = getattr(fig, "frame", {})
+    cmap = axc_color_config(frame, name).get("cmap") or cfg["fallback_cmap"]
+    is_h = axc_is_horizontal(frame, name)
     ramp = np.linspace(0.0, 1.0, int(cfg["samples"])).reshape(-1, 1)
     if is_h:
         ramp = ramp.reshape(1, -1)

{jarvisplot-2.1.4 → jarvisplot-2.1.5}/jarvisplot/Figure/figure.py

@@ -18,6 +18,7 @@ from .layer_runtime import (
     load_layer_runtime_data as runtime_load_layer_runtime_data,
     release_layer_runtime_data as runtime_release_layer_runtime_data,
     render_layer as runtime_render_layer,
+    separate_block_options,
 )
 from .layout_runtime import (
     apply_axis_endpoints,
@@ -987,14 +988,28 @@ class Figure:
             coor = ly.get("coor", {})
             style = dict(ly.get("style") or {})
             method_key = str(ly.get("method", "scatter")).lower()
+            is_separate = str(ly.get("combine", "concat")).strip().lower() in {
+                "separate",
+                "seperate",
+            }
+            block_options = (
+                separate_block_options(ly.get("layer_spec") or {}) if is_separate else {}
+            )
+            candidate_styles = [style]
+            candidate_styles.extend(
+                {**style, **dict(option.get("style") or {})}
+                for option in block_options.values()
+            )
 
-            if not layer_uses_color(style, coor, method_key):
+            if not any(layer_uses_color(item, coor, method_key) for item in candidate_styles):
                 continue
 
-            if style.get("cmap") is not None and layer_cmap_wins(
-                self, cb_name, axc_color_config(self.frame, cb_name)
-            ):
-                cb_style_cmaps.setdefault(cb_name, style.get("cmap"))
+            for candidate_style in candidate_styles:
+                if candidate_style.get("cmap") is not None and layer_cmap_wins(
+                    self, cb_name, axc_color_config(self.frame, cb_name)
+                ):
+                    cb_style_cmaps.setdefault(cb_name, candidate_style.get("cmap"))
+                    break
 
             # Load data for color range only — do not append health observations
             # (render loop will load again and observe once).
@@ -1003,11 +1018,24 @@ class Figure:
             if df is not None:
                 df = self._ensure_pandas_data(df, reason="prescan:colorbar")
                 color_cfg = axc_color_config(self.frame, cb_name)
-                lo, hi = collect_layer_color_range(
-                    df, coor, style, scale=color_cfg.get("scale"), method_key=method_key
-                )
-                if lo is not None or hi is not None:
-                    cb_ranges.setdefault(cb_name, []).append((lo, hi))
+                blocks = df.items() if isinstance(df, dict) else ((None, df),)
+                for block_key, block_df in blocks:
+                    block_style = dict(style)
+                    if block_key is not None:
+                        block_style.update(
+                            (block_options.get(block_key) or {}).get("style") or {}
+                        )
+                    if not layer_uses_color(block_style, coor, method_key):
+                        continue
+                    lo, hi = collect_layer_color_range(
+                        block_df,
+                        coor,
+                        block_style,
+                        scale=color_cfg.get("scale"),
+                        method_key=method_key,
+                    )
+                    if lo is not None or hi is not None:
+                        cb_ranges.setdefault(cb_name, []).append((lo, hi))
             # Release immediately to preserve memory profile
             runtime_release_layer_runtime_data(self, ly, consume_sources=False)
 

{jarvisplot-2.1.4 → jarvisplot-2.1.5}/jarvisplot/Figure/figure_types.py

@@ -238,7 +238,10 @@ def _profile_interp_transform(info: Mapping[str, Any], opts: Mapping[str, Any])
             "z": {"expr": z_name, "name": z_name},
         },
         "grid": opts.get("grid", interp_cfg.get("grid", 500)),
-        "nan_policy": interp_cfg.get("nan_policy", "strict"),
+        # A cell that caught no sample is not a core with an unknown value;
+        # make_interp_2d drops it either way, but the expanded YAML should say
+        # so rather than reading `strict` and meaning `ignore`.
+        "nan_policy": interp_cfg.get("nan_policy", "ignore"),
         "as_density": False,
         "normalize": False,
     }
@@ -249,6 +252,13 @@ def _profile_interp_transform(info: Mapping[str, Any], opts: Mapping[str, Any])
     for key, value in interp_cfg.items():
         if key not in {"method", "grid", "nan_policy"}:
             transform[key] = deepcopy(value)
+    # A profile map is a picture, not an integral: close the half-cell frame
+    # the hull of the cell centres leaves around the domain. posterior_density
+    # deliberately does not do this -- extrapolating a normalized density past
+    # its support would move the integral.
+    options = transform.get("backend_options", None)
+    transform["backend_options"] = dict(options) if isinstance(options, Mapping) else {}
+    transform["backend_options"].setdefault("boundary", "clamp")
     return transform
 
 

{jarvisplot-2.1.4 → jarvisplot-2.1.5}/jarvisplot/Figure/interp_2d_runtime.py

@@ -7,6 +7,7 @@ import pandas as pd
 
 from ..utils.expression import eval_dataframe_expression
 from .interp_natural_neighbor import resolve_backend
+from .interp_natural_neighbor_exact import _apply_nan_core_policy, _normalize_nan_policy
 from .posterior_mesh import (
     clipped_voronoi_cells,
     regular_support_areas,
@@ -363,17 +364,27 @@ def make_interp_2d(df: pd.DataFrame, cfg: Mapping[str, Any], logger=None) -> pd.
 
     x = _project_axis(x_raw, xlim, xscale, "x")
     y = _project_axis(y_raw, ylim, yscale, "y")
-    valid = np.isfinite(x) & np.isfinite(y) & np.isfinite(z_raw)
+    valid = np.isfinite(x) & np.isfinite(y)
     valid &= (x >= 0.0) & (x <= 1.0) & (y >= 0.0) & (y <= 1.0)
     valid_count = int(np.count_nonzero(valid))
     if valid_count < 3:
-        raise ValueError("make_interp_2d requires at least three finite support points inside the interpolation limits.")
+        raise ValueError("make_interp_2d requires at least three finite support coordinates inside the interpolation limits.")
     if valid_count != n:
         _logger_emit(logger, "warning", f"make_interp_2d dropped {n - valid_count} invalid or outside-domain support points.")
 
     as_density = bool(cfg.get("as_density", False))
     reducer = "sum" if as_density else "mean"
-    x, y, z = _dedupe_points(x[valid], y[valid], z_raw[valid], reducer=reducer)
+    # Missing values are background cores, not invalid coordinates. Resolve
+    # their policy before merging duplicates (ignore must not poison a finite
+    # sample at the same site; strict must retain the missing contribution).
+    nan_policy = _normalize_nan_policy(str(cfg.get("nan_policy", "strict")).strip() or "strict")
+    cfg = dict(cfg, nan_policy=nan_policy)
+    options = cfg.get("backend_options", {})
+    options = options if isinstance(options, Mapping) else {}
+    coords, z, nan_info = _apply_nan_core_policy(
+        np.column_stack([x[valid], y[valid]]), z_raw[valid], nan_policy, options
+    )
+    x, y, z = _dedupe_points(coords[:, 0], coords[:, 1], z, reducer=reducer)
     if len(x) < 3:
         raise ValueError("make_interp_2d requires at least three unique support points after duplicate merging.")
     x_phys = _unproject_axis(x, xlim, xscale)
@@ -432,6 +443,10 @@ def make_interp_2d(df: pd.DataFrame, cfg: Mapping[str, Any], logger=None) -> pd.
             f"\t method \t-> {method_name}\n"
             f"\t input_points \t-> {n}\n"
             f"\t valid_points \t-> {valid_count}\n"
+            f"\t nan_policy \t-> {nan_policy}\n"
+            f"\t missing_cores -> {nan_info['nan_cores']}\n"
+            f"\t dropped_cores -> {nan_info['dropped']}\n"
+            f"\t filled_cores \t-> {nan_info['filled']}\n"
             f"\t unique_points \t-> {len(x)}\n"
             f"\t xlim \t\t-> [{xlim[0]}, {xlim[1]}]\n"
             f"\t ylim \t\t-> [{ylim[0]}, {ylim[1]}]\n"
@@ -447,10 +462,30 @@ def make_interp_2d(df: pd.DataFrame, cfg: Mapping[str, Any], logger=None) -> pd.
             f"\t z_minmax \t-> {z_range}",
         )
 
-    return pd.DataFrame(
+    # The samples in this table are grid *nodes*, not arbitrary scattered
+    # points.  Preserve that geometry for pcolormesh: the axes may later use a
+    # narrower view than this interpolation domain.  Re-binning the nodes
+    # against that view changes their cell ownership (especially on a log
+    # axis), which leaves unpainted slivers between cells.
+    ix_grid, iy_grid = np.meshgrid(
+        np.arange(nx, dtype=np.int32),
+        np.arange(ny, dtype=np.int32),
+    )
+    out = pd.DataFrame(
         {
             x_out: Xp.ravel(),
             y_out: Yp.ravel(),
             z_out: np.asarray(Z, dtype=float).ravel(),
+            "__grid_ix__": ix_grid.ravel(),
+            "__grid_iy__": iy_grid.ravel(),
         }
     )
+    out["__grid_nx__"] = np.int32(nx)
+    out["__grid_ny__"] = np.int32(ny)
+    out["__grid_xmin__"] = float(xlim[0])
+    out["__grid_xmax__"] = float(xlim[1])
+    out["__grid_ymin__"] = float(ylim[0])
+    out["__grid_ymax__"] = float(ylim[1])
+    out["__grid_xscale__"] = xscale
+    out["__grid_yscale__"] = yscale
+    return out