jarvisplot 1.3.6__tar.gz → 1.3.7__tar.gz

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/JarvisPLOT.egg-info/PKG-INFO

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

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/PKG-INFO

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

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/jarvisplot/Figure/adapters_rect.py

@@ -14,6 +14,8 @@ from .helper import _auto_clip, _mask_by_extend, voronoi_finite_polygons_2d, _cl
 from .profile_runtime import grid_profile_mesh
 from .interp_natural_neighbor import resolve_backend
 
+DEFAULT_JP_SAMPLE_GRID = 500
+
 
 # —— Basic Adapter: Forward to the underlying Axes, merge default parameters, perform automatic clipping ——
 
@@ -207,7 +209,7 @@ class StdAxesAdapter:
         x,
         y,
         *,
-        bin: int = 128,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,
@@ -218,8 +220,8 @@ class StdAxesAdapter:
         if x.shape[0] != y.shape[0]:
             raise ValueError("x and y must have the same length")
 
-        nx_eff = self._coerce_positive_int(nx if nx is not None else bin, 128)
-        ny_eff = self._coerce_positive_int(ny if ny is not None else bin, 128)
+        nx_eff = self._coerce_positive_int(nx if nx is not None else bin, DEFAULT_JP_SAMPLE_GRID)
+        ny_eff = self._coerce_positive_int(ny if ny is not None else bin, DEFAULT_JP_SAMPLE_GRID)
         x_norm = self._normalize_jpfield_axis("x", x, bounds=xlim)
         y_norm = self._normalize_jpfield_axis("y", y, bounds=ylim)
         xq = np.linspace(0.0, 1.0, nx_eff)
@@ -234,7 +236,7 @@ class StdAxesAdapter:
         z,
         *,
         interp_method: str = "natural_neighbor",
-        bin: int = 128,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,
@@ -279,7 +281,7 @@ class StdAxesAdapter:
         x,
         y,
         *,
-        bin: int = 128,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,
@@ -301,8 +303,8 @@ class StdAxesAdapter:
             except Exception:
                 ylim = None
 
-        nx_eff = self._coerce_positive_int(nx if nx is not None else bin, 128)
-        ny_eff = self._coerce_positive_int(ny if ny is not None else bin, 128)
+        nx_eff = self._coerce_positive_int(nx if nx is not None else bin, DEFAULT_JP_SAMPLE_GRID)
+        ny_eff = self._coerce_positive_int(ny if ny is not None else bin, DEFAULT_JP_SAMPLE_GRID)
         xq = self._resolve_jpcontour_axis("x", x, npts=nx_eff, bounds=xlim)
         yq = self._resolve_jpcontour_axis("y", y, npts=ny_eff, bounds=ylim)
         return np.meshgrid(xq, yq)
@@ -314,7 +316,7 @@ class StdAxesAdapter:
         z,
         *,
         interp_method: str = "natural_neighbor",
-        bin: int = 128,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,
@@ -323,13 +325,19 @@ class StdAxesAdapter:
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
     ):
+        """Interpolate scattered data on an axes-fraction grid for contour rendering.
+
+        This keeps jpcontour/jpcontourf aligned with jpfield: coordinates are
+        normalized into the current Axes frame before interpolation, then the
+        contour artist is drawn with transform=ax.transAxes.
+        """
         x = np.asarray(x, dtype=float).reshape(-1)
         y = np.asarray(y, dtype=float).reshape(-1)
         z = np.asarray(z, dtype=float).reshape(-1)
         if x.shape[0] != y.shape[0] or x.shape[0] != z.shape[0]:
             raise ValueError("x, y, and z must have the same length")
 
-        X, Y = self._build_jpcontour_grid(
+        X, Y, x_norm, y_norm = self._build_jpfield_grid(
             x,
             y,
             bin=bin,
@@ -345,8 +353,8 @@ class StdAxesAdapter:
                 f"Unsupported jpcontour interpolation backend: {interp_method!r}"
             ) from exc
         Z = backend(
-            x,
-            y,
+            x_norm,
+            y_norm,
             z,
             X,
             Y,
@@ -489,7 +497,7 @@ class StdAxesAdapter:
         z,
         *args,
         interp_method: str = "natural_neighbor",
-        bin: int = 128,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,
@@ -499,7 +507,9 @@ class StdAxesAdapter:
         backend_options: Optional[dict[str, Any]] = None,
         **kwargs,
     ):
+        """Scattered-data contour plot rendered in axes-fraction coordinates."""
         kw = self._merge("contour", kwargs)
+        kw.pop("transform", None)
         X, Y, Z = self._interpolate_jpcontour_grid(
             x,
             y,
@@ -514,7 +524,14 @@ class StdAxesAdapter:
             diagnostics=diagnostics,
             backend_options=backend_options,
         )
-        artists = self.ax.contour(X, Y, np.ma.masked_invalid(Z), *args, **kw)
+        artists = self.ax.contour(
+            X,
+            Y,
+            np.ma.masked_invalid(Z),
+            *args,
+            transform=self.ax.transAxes,
+            **kw,
+        )
         return _auto_clip(artists, self.ax, self._clip_path)
 
     def jpcontourf(
@@ -524,7 +541,7 @@ class StdAxesAdapter:
         z,
         *args,
         interp_method: str = "natural_neighbor",
-        bin: int = 500,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,
@@ -534,7 +551,9 @@ class StdAxesAdapter:
         backend_options: Optional[dict[str, Any]] = None,
         **kwargs,
     ):
+        """Filled scattered-data contour plot rendered in axes-fraction coordinates."""
         kw = self._merge("contourf", kwargs)
+        kw.pop("transform", None)
         X, Y, Z = self._interpolate_jpcontour_grid(
             x,
             y,
@@ -549,7 +568,14 @@ class StdAxesAdapter:
             diagnostics=diagnostics,
             backend_options=backend_options,
         )
-        artists = self.ax.contourf(X, Y, np.ma.masked_invalid(Z), *args, **kw)
+        artists = self.ax.contourf(
+            X,
+            Y,
+            np.ma.masked_invalid(Z),
+            *args,
+            transform=self.ax.transAxes,
+            **kw,
+        )
         return _auto_clip(artists, self.ax, self._clip_path)
 
     def jpfield(
@@ -559,7 +585,7 @@ class StdAxesAdapter:
         z,
         *args,
         interp_method: str = "natural_neighbor",
-        bin: int = 128,
+        bin: int = DEFAULT_JP_SAMPLE_GRID,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         xlim=None,

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/jarvisplot/Figure/interp_natural_neighbor_exact.py

@@ -534,6 +534,8 @@ class NaturalNeighborExactInterpolator:
                     self._hull_polygon = None
                     self.diagnostics.degenerate_input = True
                     _warn("natural_neighbor: convex hull is degenerate")
+                    self.diagnostics.interpolator_ready = False
+                    return
             else:
                 self._hull_polygon = None
                 self.diagnostics.degenerate_input = True
@@ -541,6 +543,8 @@ class NaturalNeighborExactInterpolator:
             self._hull_polygon = None
             self.diagnostics.degenerate_input = True
             _warn(f"natural_neighbor: convex hull construction failed: {exc}")
+            self.diagnostics.interpolator_ready = False
+            return
 
         try:
             if coords.shape[0] >= 3:

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/jarvisplot/Figure/layer_runtime.py

@@ -48,7 +48,7 @@ def _coerce_positive_int(value, default: int) -> int:
 
 
 def _resolve_interp_grid_size(interp_cfg: dict | None, x_size: int, y_size: int) -> tuple[int, int]:
-    default_n = max(64, int(round(np.sqrt(max(int(x_size), int(y_size), 1)) * 4.0)))
+    default_n = 500
     if not isinstance(interp_cfg, dict):
         return default_n, default_n
 

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/pyproject.toml

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

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/tests/test_interp_natural_neighbor.py

@@ -186,7 +186,8 @@ def test_exact_backend_returns_nan_for_collinear_input():
     X = np.array([[1.0]])
     Y = np.array([[0.0]])
 
-    Z = natural_neighbor_exact_interpolate(x, y, z, X, Y)
+    with pytest.warns(RuntimeWarning):
+        Z = natural_neighbor_exact_interpolate(x, y, z, X, Y)
 
     assert np.isnan(Z[0, 0])
     diag = natural_neighbor_exact_interpolate.last_diagnostics

{jarvisplot-1.3.6 → jarvisplot-1.3.7}/tests/test_jpcontour_methods.py

@@ -86,6 +86,47 @@ def test_jpfield_returns_quadmesh():
     plt.close(fig)
 
 
+@pytest.mark.parametrize(
+    "method_name, mpl_name",
+    [("jpcontour", "contour"), ("jpcontourf", "contourf"), ("jpfield", "pcolormesh")],
+)
+def test_default_jp_sample_grid_is_500_when_bin_is_omitted(monkeypatch, method_name, mpl_name):
+    fig, ax = plt.subplots()
+    adapter = StdAxesAdapter(ax)
+
+    backend_calls = {}
+
+    def fake_backend(
+        x,
+        y,
+        z,
+        X,
+        Y,
+        *,
+        nan_policy="strict",
+        diagnostics=False,
+        backend_options=None,
+    ):
+        backend_calls["grid_shape"] = X.shape
+        return np.asarray(X + Y, dtype=float)
+
+    monkeypatch.setattr(adapters_rect_mod, "resolve_backend", lambda name: fake_backend)
+    monkeypatch.setattr(adapter.ax, mpl_name, lambda *args, **kwargs: SimpleNamespace(tag=method_name))
+
+    x = np.array([0.0, 1.0, 0.0, 1.0])
+    y = np.array([0.0, 0.0, 1.0, 1.0])
+    z = np.array([0.0, 1.0, 1.0, 2.0])
+
+    if method_name == "jpfield":
+        out = getattr(adapter, method_name)(x, y, z, cmap="viridis")
+    else:
+        out = getattr(adapter, method_name)(x, y, z, levels=3, cmap="viridis")
+
+    assert out.tag == method_name
+    assert backend_calls["grid_shape"] == (500, 500)
+    plt.close(fig)
+
+
 @pytest.mark.parametrize("method_name", ["jpcontour", "jpcontourf"])
 def test_render_layer_dispatches_jpcontour_methods_with_scattered_inputs(monkeypatch, method_name):
     df = pd.DataFrame(
@@ -163,6 +204,8 @@ def test_jpcontour_strips_interp_kwargs_and_preserves_masked_nan_grid(monkeypatc
         diagnostics=False,
         backend_options=None,
     ):
+        backend_calls["x"] = np.asarray(x, dtype=float)
+        backend_calls["y"] = np.asarray(y, dtype=float)
         backend_calls["nan_policy"] = nan_policy
         backend_calls["diagnostics"] = diagnostics
         backend_calls["backend_options"] = backend_options
@@ -184,8 +227,8 @@ def test_jpcontour_strips_interp_kwargs_and_preserves_masked_nan_grid(monkeypatc
 
     monkeypatch.setattr(adapter.ax, mpl_name, recorder)
 
-    x = np.array([0.0, 1.0, 0.0, 1.0])
-    y = np.array([0.0, 0.0, 1.0, 1.0])
+    x = np.array([0.0, 1.0, 2.0, 2.0])
+    y = np.array([0.0, 0.5, 1.5, 2.0])
     z = np.array([0.0, 1.0, 1.0, 2.0])
 
     out = getattr(adapter, method_name)(
@@ -199,8 +242,8 @@ def test_jpcontour_strips_interp_kwargs_and_preserves_masked_nan_grid(monkeypatc
         bin=6,
         nx=4,
         ny=5,
-        xlim=(-1.0, 1.0),
-        ylim=(-2.0, 2.0),
+        xlim=(0.0, 2.0),
+        ylim=(0.0, 2.0),
         nan_policy="strict",
         diagnostics=True,
         backend_options={"vertex_tol": 1.0e-6},
@@ -211,10 +254,15 @@ def test_jpcontour_strips_interp_kwargs_and_preserves_masked_nan_grid(monkeypatc
     assert backend_calls["diagnostics"] is True
     assert backend_calls["backend_options"] == {"vertex_tol": 1.0e-6}
     assert backend_calls["grid_shape"] == (5, 4)
-    assert backend_calls["x_range"] == (-1.0, 1.0)
-    assert backend_calls["y_range"] == (-2.0, 2.0)
+    assert backend_calls["x_range"] == (0.0, 1.0)
+    assert backend_calls["y_range"] == (0.0, 1.0)
+    np.testing.assert_allclose(backend_calls["x"], np.array([0.0, 0.5, 1.0, 1.0]))
+    np.testing.assert_allclose(backend_calls["y"], np.array([0.0, 0.25, 0.75, 1.0]))
 
-    assert mpl_calls["kwargs"] == {"levels": 3, "colors": "k", "linewidths": 2.0}
+    assert mpl_calls["kwargs"]["levels"] == 3
+    assert mpl_calls["kwargs"]["colors"] == "k"
+    assert mpl_calls["kwargs"]["linewidths"] == 2.0
+    assert mpl_calls["kwargs"]["transform"] is adapter.ax.transAxes
     z_arg = mpl_calls["args"][2]
     assert np.ma.isMaskedArray(z_arg)
     mask = np.ma.getmaskarray(z_arg)
@@ -224,6 +272,73 @@ def test_jpcontour_strips_interp_kwargs_and_preserves_masked_nan_grid(monkeypatc
     plt.close(fig)
 
 
+def test_render_layer_contourf_defaults_to_500_grid_when_interp_bin_missing(monkeypatch):
+    df = pd.DataFrame(
+        {
+            "x": [0.0, 1.0, 0.0, 1.0],
+            "y": [0.0, 0.0, 1.0, 1.0],
+            "z": [0.0, 1.0, 1.0, 2.0],
+        }
+    )
+
+    fig = SimpleNamespace(
+        logger=SimpleNamespace(debug=lambda *args, **kwargs: None, warning=lambda *args, **kwargs: None),
+        style={"contourf": {"interp": {"method": "natural_neighbor"}, "levels": 3}},
+        _ensure_pandas_data=lambda data, reason="render": data,
+        _eval_series=lambda data, spec: np.asarray(data[spec["expr"]]),
+    )
+
+    ax = SimpleNamespace(
+        _type="rect",
+        get_xscale=lambda: "linear",
+        get_yscale=lambda: "linear",
+        get_xlim=lambda: (0.0, 1.0),
+        get_ylim=lambda: (0.0, 1.0),
+    )
+
+    backend_calls = {}
+
+    def fake_backend(
+        x,
+        y,
+        z,
+        X,
+        Y,
+        *,
+        nan_policy="strict",
+        diagnostics=False,
+        backend_options=None,
+    ):
+        backend_calls["grid_shape"] = X.shape
+        return X + Y
+
+    method_calls = {}
+
+    def dummy_method(*args, **kwargs):
+        method_calls["kwargs"] = dict(kwargs)
+        return "ok"
+
+    monkeypatch.setattr(layer_runtime_mod, "resolve_backend", lambda name: fake_backend)
+    monkeypatch.setattr(layer_runtime_mod, "resolve_callable", lambda *args, **kwargs: (dummy_method, None))
+    monkeypatch.setattr(layer_runtime_mod, "collect_and_attach_colorbar", lambda *args, **kwargs: args[1])
+
+    out = layer_runtime_mod.render_layer(
+        fig,
+        ax,
+        {
+            "name": "contourf-layer",
+            "method": "contourf",
+            "data": df,
+            "coor": {"x": {"expr": "x"}, "y": {"expr": "y"}, "z": {"expr": "z"}},
+            "style": {},
+        },
+    )
+
+    assert out == "ok"
+    assert backend_calls["grid_shape"] == (500, 500)
+    assert method_calls["kwargs"]["levels"] == 3
+
+
 def test_jpfield_strips_interp_kwargs_and_preserves_masked_nan_grid(monkeypatch):
     fig, ax = plt.subplots()
     adapter = StdAxesAdapter(ax)
@@ -457,6 +572,7 @@ def test_ternary_jpcontourf_accepts_left_right_bottom(monkeypatch):
     np.testing.assert_allclose(backend_calls["y"], expected_y)
     np.testing.assert_allclose(backend_calls["z"], z)
     assert mpl_calls["kwargs"]["levels"] == 4
+    assert mpl_calls["kwargs"]["transform"] is adapter.ax.transAxes
     plt.close(fig)
 
 
@@ -626,4 +742,5 @@ def test_jpcontour_strips_interpolation_kwargs_from_mpl_call(monkeypatch):
     assert "ylim" not in mpl_calls["kwargs"]
     assert "nan_policy" not in mpl_calls["kwargs"]
     assert "backend_options" not in mpl_calls["kwargs"]
+    assert mpl_calls["kwargs"]["transform"] is adapter.ax.transAxes
     plt.close(fig)