jarvisplot 1.4.0__tar.gz → 1.4.1__tar.gz

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/JarvisPLOT.egg-info/PKG-INFO

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

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/PKG-INFO

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

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/jarvisplot/Figure/colorbar_runtime.py

@@ -394,6 +394,8 @@ def collect_and_attach_colorbar(
     if not axc._cb.get("used"):
         frame = getattr(fig, "frame", {})
         color_cfg = axc_color_config(frame, cb_name)
+        if color_cfg.get("cmap") is None and style.get("cmap") is not None:
+            color_cfg["cmap"] = style.get("cmap")
         data_range = collect_layer_color_range(
             df,
             coor,

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/jarvisplot/Figure/figure.py

@@ -711,6 +711,7 @@ class Figure:
         read-only during the main render loop.
         """
         cb_ranges: dict[str, list] = {}
+        cb_style_cmaps: dict[str, object] = {}
 
         for ax, ly in self._render_queue:
             cb_name = ly.get("colorbar", "axc")
@@ -724,6 +725,9 @@ class Figure:
             if not layer_uses_color(style, coor, method_key):
                 continue
 
+            if style.get("cmap") is not None:
+                cb_style_cmaps.setdefault(cb_name, style.get("cmap"))
+
             # Load data (pipeline cache hit on second call in render loop)
             runtime_load_layer_runtime_data(self, ly)
             df = ly.get("data")
@@ -742,6 +746,8 @@ class Figure:
             if axc_obj is None or not hasattr(axc_obj, "_cb"):
                 continue
             color_cfg = axc_color_config(self.frame, cb_name)
+            if color_cfg.get("cmap") is None and cb_name in cb_style_cmaps:
+                color_cfg["cmap"] = cb_style_cmaps[cb_name]
             axc_obj._cb.update(
                 precompute_colorbar_cb(color_cfg, ranges, logger=self.logger)
             )

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/jarvisplot/Figure/layer_runtime.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
+from matplotlib.path import Path as MplPath
 
 from .preprocessor_runtime import add_column, filter_df, sort_by
 from .profile_runtime import profiling
@@ -15,6 +16,117 @@ from .interp_natural_neighbor import resolve_backend
 from .dynesty_runtime import render_dynesty_runplot
 from .posterior_hpd import prepare_hpd_contour_style
 
+_MISSING_CLIP_PATH = object()
+
+
+def _clip_expr_inside(expr: str, point) -> bool:
+    px, py = float(point[0]), float(point[1])
+    env = {
+        "x": px,
+        "y": py,
+        "np": np,
+        "numpy": np,
+        "abs": abs,
+        "min": min,
+        "max": max,
+    }
+    try:
+        return bool(eval(expr, {"__builtins__": {}}, env))
+    except Exception as exc:
+        raise ValueError(f"layer clip_expr failed for {expr!r}: {exc}") from exc
+
+
+def _clip_polygon_to_expr(poly, expr: str, *, iterations: int = 48):
+    """Clip a polygon to the region where expr is True in data coordinates."""
+    expr = str(expr or "").strip()
+    if not expr or not poly:
+        return poly
+
+    def inside(pt) -> bool:
+        return _clip_expr_inside(expr, pt)
+
+    def intersect(a, b):
+        pa = np.asarray(a, dtype=float)
+        pb = np.asarray(b, dtype=float)
+        a_inside = inside(pa)
+        lo = pa
+        hi = pb
+        for _ in range(iterations):
+            mid = 0.5 * (lo + hi)
+            if inside(mid) == a_inside:
+                lo = mid
+            else:
+                hi = mid
+        return tuple(0.5 * (lo + hi))
+
+    out = []
+    start = poly[-1]
+    start_inside = inside(start)
+    for end in poly:
+        end_inside = inside(end)
+        if end_inside:
+            if not start_inside:
+                out.append(intersect(start, end))
+            out.append(end)
+        elif start_inside:
+            out.append(intersect(start, end))
+        start = end
+        start_inside = end_inside
+    return out
+
+
+def _layer_clip_path_from_style(ax, style: dict):
+    expr = style.pop("clip_expr", style.pop("clip_where", None))
+    if expr is None:
+        return None
+    raw_ax = getattr(ax, "ax", ax)
+    try:
+        x0, x1 = raw_ax.get_xlim()
+        y0, y1 = raw_ax.get_ylim()
+    except Exception as exc:
+        raise ValueError("layer clip_expr requires axes with data limits") from exc
+
+    xmin, xmax = sorted((float(x0), float(x1)))
+    ymin, ymax = sorted((float(y0), float(y1)))
+    rect = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]
+    clipped = _clip_polygon_to_expr(rect, str(expr))
+    if len(clipped) < 3:
+        return MplPath([(xmin, ymin), (xmin, ymin)], [MplPath.MOVETO, MplPath.CLOSEPOLY])
+
+    vertices = list(clipped) + [tuple(clipped[0])]
+    codes = [MplPath.MOVETO] + [MplPath.LINETO] * (len(clipped) - 1) + [MplPath.CLOSEPOLY]
+    return MplPath(vertices, codes)
+
+
+def _layer_clip_targets(ax):
+    raw_ax = getattr(ax, "ax", None)
+    targets = []
+    for obj in (ax, raw_ax):
+        if obj is not None and not any(obj is prev for prev in targets):
+            targets.append(obj)
+    return targets
+
+
+def _call_with_layer_clip(ax, clip_path, func, *args, **kwargs):
+    if clip_path is None:
+        return func(*args, **kwargs)
+
+    states = []
+    for target in _layer_clip_targets(ax):
+        states.append((target, getattr(target, "_clip_path", _MISSING_CLIP_PATH)))
+        target._clip_path = clip_path
+    try:
+        return func(*args, **kwargs)
+    finally:
+        for target, previous in reversed(states):
+            if previous is _MISSING_CLIP_PATH:
+                try:
+                    delattr(target, "_clip_path")
+                except Exception:
+                    pass
+            else:
+                target._clip_path = previous
+
 
 def _resolve_csv_export_path(fig, target):
     if isinstance(target, dict):
@@ -664,6 +776,7 @@ def render_layer(fig, ax, layer_info):
             pass
     if layer_info.get("style", {}) is not None:
         style.update(layer_info.get("style", {}))
+    layer_clip_path = _layer_clip_path_from_style(ax, style)
 
     cb_name = layer_info.get("colorbar", "axc")
 
@@ -696,8 +809,8 @@ def render_layer(fig, ax, layer_info):
                 required_keys=("z",),
                 include_diagnostics=method_key in {"jpcontour", "jpcontourf"},
             )
-            return method(**jp_kwargs)
-        return method(**style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **jp_kwargs)
+        return _call_with_layer_clip(ax, layer_clip_path, method, **style)
 
     elif getattr(ax, "_type", None) == "rect":
         df = fig._ensure_pandas_data(layer_info["data"], reason=f"render:{layer_info.get('name', '')}")
@@ -724,7 +837,7 @@ def render_layer(fig, ax, layer_info):
                 for kk, vv in coor.items():
                     style[kk] = fig._eval_series(df, vv)
 
-            return method(**style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **style)
         if method_key in {"jpcontour", "jpcontourf", "jpfield"}:
             jp_kwargs = _prepare_jpcontour_style(
                 fig,
@@ -737,7 +850,7 @@ def render_layer(fig, ax, layer_info):
                 required_keys=("x", "y", "z"),
                 include_diagnostics=method_key in {"jpcontour", "jpcontourf"},
             )
-            return method(**jp_kwargs)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **jp_kwargs)
         if method_key in {"contour", "contourf"}:
             contour_coor = {}
             for kk in ("x", "y", "z"):
@@ -759,7 +872,7 @@ def render_layer(fig, ax, layer_info):
             contour_args, style = _prepare_contour_args(fig, ax.ax if hasattr(ax, "ax") else ax, method_key, style, contour_coor, df=df)
             if contour_args is None:
                 return []
-            return method(*contour_args, **style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, *contour_args, **style)
         else:
             if not ({"x", "y"} <= set(coor.keys())):
                 raise ValueError("Rectangular layer must define coordinates: {x,y} with exprs.")
@@ -777,7 +890,7 @@ def render_layer(fig, ax, layer_info):
             if method_key == "pcolormesh":
                 style["__df__"] = df
             style.pop("interp", None)
-            return method(**style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **style)
 
     else:
         raise ValueError(f"Axes '{ax}' has unknown _type='{getattr(ax, '_type', None)}'.")

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/jarvisplot/flowchart.py

@@ -276,13 +276,20 @@ class FlowchartRenderer:
         from shapely.geometry import Point, box
         from shapely.ops import unary_union
         x, y = item["pos"] 
-        circle1 = Point(x-0.15, y).buffer(0.15, resolution=128)
-        circle2 = Point(x+0.15, y).buffer(0.15, resolution=128)
+
+        def point_buffer(point, radius, segments=128):
+            try:
+                return point.buffer(radius, quad_segs=segments)
+            except TypeError:
+                return point.buffer(radius, resolution=segments)
+
+        circle1 = point_buffer(Point(x-0.15, y), 0.15)
+        circle2 = point_buffer(Point(x+0.15, y), 0.15)
         square = box(x - 0.15, y - 0.15, x + 0.15, y + 0.15)
         merged = unary_union([circle1, circle2, square])
         xx, yy = merged.exterior.xy
         ax.fill(xx, yy, alpha=0.95, edgecolor="#F9F9F8", facecolor="#00D86B", linewidth=0.1, zorder=120)
-        circle3 = Point(x-0.15, y).buffer(0.12, resolution=128)
+        circle3 = point_buffer(Point(x-0.15, y), 0.12)
         xx, yy = circle3.exterior.xy
         ax.fill(xx, yy, alpha=0.95, edgecolor="#FFFFFF", facecolor="#F9F9F8", linewidth=0.8, zorder=120)
         import matplotlib.patheffects as pe

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/pyproject.toml

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

{jarvisplot-1.4.0 → jarvisplot-1.4.1}/tests/test_figure_contracts.py

@@ -224,6 +224,41 @@ def test_figure_set_alias_removed():
     assert not hasattr(Figure, "set")
 
 
+def test_layer_clip_expr_builds_data_space_clip_path():
+    _, raw_ax = plt.subplots()
+    raw_ax.set_xlim(0.0, 10.0)
+    raw_ax.set_ylim(0.0, 10.0)
+    ax = SimpleNamespace(ax=raw_ax)
+    style = {"clip_expr": "x >= 2 * y", "cmap": "viridis"}
+
+    clip_path = layer_runtime_mod._layer_clip_path_from_style(ax, style)
+
+    assert "clip_expr" not in style
+    assert style["cmap"] == "viridis"
+    assert len(clip_path.vertices) >= 3
+    assert all(px >= 2 * py - 1e-10 for px, py in clip_path.vertices)
+    plt.close(raw_ax.figure)
+
+
+def test_layer_clip_is_temporary_on_adapter_and_raw_axes():
+    raw_ax = SimpleNamespace(_clip_path="raw-original")
+    adapter = SimpleNamespace(ax=raw_ax, _clip_path="adapter-original")
+    clip_path = object()
+    observed = {}
+
+    def draw():
+        observed["adapter"] = adapter._clip_path
+        observed["raw"] = raw_ax._clip_path
+        return "drawn"
+
+    out = layer_runtime_mod._call_with_layer_clip(adapter, clip_path, draw)
+
+    assert out == "drawn"
+    assert observed == {"adapter": clip_path, "raw": clip_path}
+    assert adapter._clip_path == "adapter-original"
+    assert raw_ax._clip_path == "raw-original"
+
+
 def test_colorbar_contract_uses_frame_color_config():
     class DummyColorbarAxis:
         def __init__(self):
@@ -259,6 +294,106 @@ def test_colorbar_contract_uses_frame_color_config():
     assert fig.axc._cb["vmax"] == 10.0
 
 
+def test_colorbar_contract_falls_back_to_layer_cmap_when_frame_omits_cmap():
+    class DummyColorbarAxis:
+        def __init__(self):
+            self._cb = {
+                "cmap": None,
+                "vmin": None,
+                "vmax": None,
+                "norm": None,
+                "levels": None,
+                "used": False,
+            }
+
+    fig = SimpleNamespace(
+        axes={"axc": DummyColorbarAxis()},
+        frame={"axc": {"color": {"scale": "linear"}}},
+        logger=_logger(),
+    )
+
+    out = collect_and_attach_colorbar(
+        fig,
+        style={"cmap": "jarvis_rainbow2_r"},
+        coor={"z": {"expr": "z"}},
+        method_key="voronoi",
+        df=pd.DataFrame({"z": [1, 2, 5]}),
+    )
+
+    assert out["cmap"] == "jarvis_rainbow2_r"
+    assert fig.axes["axc"]._cb["cmap"] == "jarvis_rainbow2_r"
+
+
+def test_prescan_colorbar_uses_layer_cmap_when_frame_omits_cmap():
+    class DummyColorbarAxis:
+        def __init__(self):
+            self._cb = {
+                "cmap": None,
+                "vmin": None,
+                "vmax": None,
+                "norm": None,
+                "levels": None,
+                "used": False,
+            }
+
+    fig = Figure()
+    fig.logger = _logger()
+    fig.frame = {"axc": {"color": {"scale": "linear"}}}
+    fig.axes = {"axc": DummyColorbarAxis()}
+    layer = {
+        "name": "colored_voronoi",
+        "method": "voronoi",
+        "style": {"cmap": "jarvis_rainbow2_r"},
+        "coor": {"z": {"expr": "z"}},
+        "colorbar": "axc",
+        "data": pd.DataFrame({"z": [1, 2, 5]}),
+        "data_loaded": True,
+        "layer_spec": {},
+        "source_refs": [],
+        "share_name": None,
+    }
+    fig._render_queue = [(None, layer)]
+
+    fig._prescan_colorbar_ranges()
+
+    assert fig.axes["axc"]._cb["cmap"] == "jarvis_rainbow2_r"
+
+
+def test_prescan_colorbar_frame_cmap_overrides_layer_cmap():
+    class DummyColorbarAxis:
+        def __init__(self):
+            self._cb = {
+                "cmap": None,
+                "vmin": None,
+                "vmax": None,
+                "norm": None,
+                "levels": None,
+                "used": False,
+            }
+
+    fig = Figure()
+    fig.logger = _logger()
+    fig.frame = {"axc": {"color": {"scale": "linear", "cmap": "viridis"}}}
+    fig.axes = {"axc": DummyColorbarAxis()}
+    layer = {
+        "name": "colored_voronoi",
+        "method": "voronoi",
+        "style": {"cmap": "jarvis_rainbow2_r"},
+        "coor": {"z": {"expr": "z"}},
+        "colorbar": "axc",
+        "data": pd.DataFrame({"z": [1, 2, 5]}),
+        "data_loaded": True,
+        "layer_spec": {},
+        "source_refs": [],
+        "share_name": None,
+    }
+    fig._render_queue = [(None, layer)]
+
+    fig._prescan_colorbar_ranges()
+
+    assert fig.axes["axc"]._cb["cmap"] == "viridis"
+
+
 def test_colorbar_attachment_skips_plain_scatter_without_color_channel():
     class DummyColorbarAxis:
         def __init__(self):