jarvisplot 1.3.4__tar.gz → 1.3.6__tar.gz

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

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

{jarvisplot-1.3.4 → jarvisplot-1.3.6}/JarvisPLOT.egg-info/SOURCES.txt

@@ -21,7 +21,6 @@ jarvisplot/data_loader_summary.py
 jarvisplot/inner_func.py
 jarvisplot/memtrace.py
 jarvisplot/Figure/__init__.py
-jarvisplot/Figure/adapters.py
 jarvisplot/Figure/adapters_rect.py
 jarvisplot/Figure/adapters_ternary.py
 jarvisplot/Figure/colorbar_runtime.py
@@ -29,9 +28,10 @@ jarvisplot/Figure/config_runtime.py
 jarvisplot/Figure/data_pipelines.py
 jarvisplot/Figure/figure.py
 jarvisplot/Figure/helper.py
+jarvisplot/Figure/interp_natural_neighbor.py
+jarvisplot/Figure/interp_natural_neighbor_exact.py
 jarvisplot/Figure/layer_runtime.py
 jarvisplot/Figure/layout_runtime.py
-jarvisplot/Figure/load_data.py
 jarvisplot/Figure/method_registry.py
 jarvisplot/Figure/preprocessor.py
 jarvisplot/Figure/preprocessor_runtime.py
@@ -61,13 +61,16 @@ jarvisplot/cards/icons/gambit.png
 jarvisplot/cards/icons/gambit_small.png
 jarvisplot/utils/__init__.py
 jarvisplot/utils/cmaps.py
+jarvisplot/utils/dataframes.py
 jarvisplot/utils/expression.py
 jarvisplot/utils/interpolator.py
 jarvisplot/utils/pathing.py
 tests/test_data_loader_contracts.py
 tests/test_docs_status_labels.py
 tests/test_figure_contracts.py
+tests/test_interp_natural_neighbor.py
 tests/test_interpolator_contracts.py
+tests/test_jpcontour_methods.py
 tests/test_parse_data_metadata.py
 tests/test_pathing_contracts.py
 tests/test_template_json.py

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

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

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

@@ -5,12 +5,14 @@ from typing import Any, Dict, Optional
 import numpy as np
 import os
 import json
+import warnings
 
 from matplotlib.axes import Axes
 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_profile_mesh
+from .interp_natural_neighbor import resolve_backend
 
 
 # —— Basic Adapter: Forward to the underlying Axes, merge default parameters, perform automatic clipping ——
@@ -52,6 +54,308 @@ class StdAxesAdapter:
         base.update(kwargs or {})
         return base
 
+    @staticmethod
+    def _coerce_positive_int(value, default: int) -> int:
+        try:
+            n = int(value)
+            if n > 0:
+                return n
+        except Exception:
+            pass
+        return int(default)
+
+    def _resolve_jpcontour_axis(self, axis_name: str, values, *, npts: int, bounds=None):
+        values = np.asarray(values, dtype=float).reshape(-1)
+        finite = values[np.isfinite(values)]
+
+        try:
+            scale = str(self.ax.get_xscale() if axis_name == "x" else self.ax.get_yscale()).lower()
+        except Exception:
+            scale = "linear"
+
+        if bounds is None:
+            if finite.size:
+                lo = float(np.min(finite))
+                hi = float(np.max(finite))
+            else:
+                try:
+                    lo, hi = self.ax.get_xlim() if axis_name == "x" else self.ax.get_ylim()
+                    lo = float(lo)
+                    hi = float(hi)
+                except Exception:
+                    lo, hi = 0.0, 1.0
+        else:
+            try:
+                lo = float(bounds[0])
+                hi = float(bounds[1])
+            except Exception:
+                lo, hi = 0.0, 1.0
+
+        if not np.isfinite(lo) or not np.isfinite(hi):
+            if finite.size:
+                lo = float(np.min(finite))
+                hi = float(np.max(finite))
+            else:
+                lo, hi = 0.0, 1.0
+
+        if lo == hi:
+            if scale == "log" and lo > 0:
+                hi = lo * 10.0
+            else:
+                hi = lo + 1.0
+
+        if scale == "log":
+            positive = finite[finite > 0]
+            if lo <= 0 or hi <= 0:
+                if positive.size:
+                    lo = float(np.min(positive))
+                    hi = float(np.max(positive))
+                else:
+                    warnings.warn(
+                        f"jpcontour: {axis_name}-axis is log-scaled but has no positive finite values; "
+                        "falling back to a linear grid",
+                        RuntimeWarning,
+                        stacklevel=3,
+                    )
+                    return np.linspace(lo, hi, npts)
+            lo = max(lo, np.finfo(float).tiny)
+            hi = max(hi, lo * 10.0)
+            return np.geomspace(lo, hi, npts)
+
+        return np.linspace(lo, hi, npts)
+
+    def _normalize_jpfield_axis(self, axis_name: str, values, *, bounds=None):
+        """Map data coordinates onto axes-fraction coordinates in [0, 1].
+
+        This is used by jpfield so interpolation and rendering both happen in
+        the axes transform frame, avoiding mixed log/linear geometry.
+        """
+        values = np.asarray(values, dtype=float).reshape(-1)
+        out = np.full(values.shape, np.nan, dtype=float)
+
+        try:
+            scale = str(self.ax.get_xscale() if axis_name == "x" else self.ax.get_yscale()).lower()
+        except Exception:
+            scale = "linear"
+
+        if bounds is None:
+            try:
+                bounds = self.ax.get_xlim() if axis_name == "x" else self.ax.get_ylim()
+            except Exception:
+                bounds = None
+
+        if bounds is None:
+            finite = values[np.isfinite(values)]
+            if finite.size:
+                lo = float(np.min(finite))
+                hi = float(np.max(finite))
+            else:
+                lo, hi = 0.0, 1.0
+        else:
+            try:
+                lo = float(bounds[0])
+                hi = float(bounds[1])
+            except Exception:
+                lo, hi = 0.0, 1.0
+
+        if not np.isfinite(lo) or not np.isfinite(hi):
+            finite = values[np.isfinite(values)]
+            if finite.size:
+                lo = float(np.min(finite))
+                hi = float(np.max(finite))
+            else:
+                lo, hi = 0.0, 1.0
+
+        if lo == hi:
+            if scale == "log" and lo > 0:
+                hi = lo * 10.0
+            else:
+                hi = lo + 1.0
+
+        if scale == "log":
+            positive = values[np.isfinite(values) & (values > 0)]
+            if lo <= 0 or hi <= 0:
+                if positive.size:
+                    lo = float(np.min(positive))
+                    hi = float(np.max(positive))
+                else:
+                    warnings.warn(
+                        f"jpfield: {axis_name}-axis is log-scaled but has no positive finite values; "
+                        "rendering an empty field in axes-fraction space",
+                        RuntimeWarning,
+                        stacklevel=3,
+                    )
+                    return out
+            lo = max(lo, np.finfo(float).tiny)
+            hi = max(hi, lo * 10.0)
+            den = np.log(hi) - np.log(lo)
+            if den == 0:
+                den = 1.0
+            valid = np.isfinite(values) & (values > 0)
+            out[valid] = (np.log(values[valid]) - np.log(lo)) / den
+            return out
+
+        den = hi - lo
+        if den == 0:
+            den = 1.0
+        valid = np.isfinite(values)
+        out[valid] = (values[valid] - lo) / den
+        return out
+
+    def _build_jpfield_grid(
+        self,
+        x,
+        y,
+        *,
+        bin: int = 128,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+    ):
+        x = np.asarray(x, dtype=float).reshape(-1)
+        y = np.asarray(y, dtype=float).reshape(-1)
+        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)
+        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)
+        yq = np.linspace(0.0, 1.0, ny_eff)
+        X, Y = np.meshgrid(xq, yq)
+        return X, Y, x_norm, y_norm
+
+    def _interpolate_jpfield_grid(
+        self,
+        x,
+        y,
+        z,
+        *,
+        interp_method: str = "natural_neighbor",
+        bin: int = 128,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+        nan_policy: str = "strict",
+        backend_options: Optional[dict[str, Any]] = None,
+    ):
+        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, x_norm, y_norm = self._build_jpfield_grid(
+            x,
+            y,
+            bin=bin,
+            nx=nx,
+            ny=ny,
+            xlim=xlim,
+            ylim=ylim,
+        )
+        try:
+            backend = resolve_backend(interp_method)
+        except Exception as exc:
+            raise ValueError(
+                f"Unsupported jpfield interpolation backend: {interp_method!r}"
+            ) from exc
+        Z = backend(
+            x_norm,
+            y_norm,
+            z,
+            X,
+            Y,
+            nan_policy=nan_policy,
+            backend_options=backend_options,
+        )
+        return X, Y, np.asarray(Z, dtype=float)
+
+    def _build_jpcontour_grid(
+        self,
+        x,
+        y,
+        *,
+        bin: int = 128,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+    ):
+        x = np.asarray(x, dtype=float).reshape(-1)
+        y = np.asarray(y, dtype=float).reshape(-1)
+        if x.shape[0] != y.shape[0]:
+            raise ValueError("x and y must have the same length")
+
+        if xlim is None:
+            try:
+                xlim = self.ax.get_xlim()
+            except Exception:
+                xlim = None
+        if ylim is None:
+            try:
+                ylim = self.ax.get_ylim()
+            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)
+        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)
+
+    def _interpolate_jpcontour_grid(
+        self,
+        x,
+        y,
+        z,
+        *,
+        interp_method: str = "natural_neighbor",
+        bin: int = 128,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+        nan_policy: str = "strict",
+        diagnostics: bool = False,
+        backend_options: Optional[dict[str, Any]] = None,
+    ):
+        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,
+            bin=bin,
+            nx=nx,
+            ny=ny,
+            xlim=xlim,
+            ylim=ylim,
+        )
+        try:
+            backend = resolve_backend(interp_method)
+        except Exception as exc:
+            raise ValueError(
+                f"Unsupported jpcontour interpolation backend: {interp_method!r}"
+            ) from exc
+        Z = backend(
+            x,
+            y,
+            z,
+            X,
+            Y,
+            nan_policy=nan_policy,
+            diagnostics=diagnostics,
+            backend_options=backend_options,
+        )
+        return X, Y, np.asarray(Z, dtype=float)
+
     # —— Common method forwarding (add as needed) ——
     def scatter(self, **kwargs):
         x, y = kwargs.pop("x"), kwargs.pop("y")
@@ -71,7 +375,7 @@ class StdAxesAdapter:
         df = kwargs.pop("__df__", None)
         kw = self._merge("grid_profile", kwargs)
 
-        # Keep compatibility with configs copied from tripcolor/scatter.
+        # Strip kwargs that are not used by grid_profile rendering.
         for k in ("shading", "levels", "extend", "space", "marker", "s", "c"):
             kw.pop(k, None)
 
@@ -178,6 +482,146 @@ class StdAxesAdapter:
         artists = self.ax.contourf(*args, **kw)
         return _auto_clip(artists, self.ax, self._clip_path)
 
+    def jpcontour(
+        self,
+        x,
+        y,
+        z,
+        *args,
+        interp_method: str = "natural_neighbor",
+        bin: int = 128,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+        nan_policy: str = "strict",
+        diagnostics: bool = False,
+        backend_options: Optional[dict[str, Any]] = None,
+        **kwargs,
+    ):
+        kw = self._merge("contour", kwargs)
+        X, Y, Z = self._interpolate_jpcontour_grid(
+            x,
+            y,
+            z,
+            interp_method=interp_method,
+            bin=bin,
+            nx=nx,
+            ny=ny,
+            xlim=xlim,
+            ylim=ylim,
+            nan_policy=nan_policy,
+            diagnostics=diagnostics,
+            backend_options=backend_options,
+        )
+        artists = self.ax.contour(X, Y, np.ma.masked_invalid(Z), *args, **kw)
+        return _auto_clip(artists, self.ax, self._clip_path)
+
+    def jpcontourf(
+        self,
+        x,
+        y,
+        z,
+        *args,
+        interp_method: str = "natural_neighbor",
+        bin: int = 500,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+        nan_policy: str = "strict",
+        diagnostics: bool = False,
+        backend_options: Optional[dict[str, Any]] = None,
+        **kwargs,
+    ):
+        kw = self._merge("contourf", kwargs)
+        X, Y, Z = self._interpolate_jpcontour_grid(
+            x,
+            y,
+            z,
+            interp_method=interp_method,
+            bin=bin,
+            nx=nx,
+            ny=ny,
+            xlim=xlim,
+            ylim=ylim,
+            nan_policy=nan_policy,
+            diagnostics=diagnostics,
+            backend_options=backend_options,
+        )
+        artists = self.ax.contourf(X, Y, np.ma.masked_invalid(Z), *args, **kw)
+        return _auto_clip(artists, self.ax, self._clip_path)
+
+    def jpfield(
+        self,
+        x,
+        y,
+        z,
+        *args,
+        interp_method: str = "natural_neighbor",
+        bin: int = 128,
+        nx: Optional[int] = None,
+        ny: Optional[int] = None,
+        xlim=None,
+        ylim=None,
+        nan_policy: str = "strict",
+        backend_options: Optional[dict[str, Any]] = None,
+        shading: str = "auto",
+        **kwargs,
+    ):
+        """Scattered-data field plot.
+
+        Interpolates scattered x/y/z samples onto a regular grid in axes-fraction
+        space, then renders the result with pcolormesh(transform=ax.transAxes).
+        The plot is drawn from explicit cell edges so raster backends do not
+        introduce a half-cell seam.
+        Undefined regions remain masked. Contour-only kwargs such as levels /
+        colors / extend are ignored.
+        """
+        kw = self._merge("pcolormesh", kwargs)
+        for k in ("levels", "extend", "locator", "corner_mask", "colors", "linestyles"):
+            kw.pop(k, None)
+        kw.pop("shading", None)
+        kw.pop("transform", None)
+        X, Y, Z = self._interpolate_jpfield_grid(
+            x,
+            y,
+            z,
+            interp_method=interp_method,
+            bin=bin,
+            nx=nx,
+            ny=ny,
+            xlim=xlim,
+            ylim=ylim,
+            nan_policy=nan_policy,
+            backend_options=backend_options,
+        )
+        X = np.asarray(X, dtype=float)
+        Y = np.asarray(Y, dtype=float)
+        Z = np.ma.masked_invalid(np.asarray(Z, dtype=float))
+        if str(shading).lower() in {"auto", "flat"}:
+            ny, nx = Z.shape
+            xe = np.linspace(0.0, 1.0, nx + 1)
+            ye = np.linspace(0.0, 1.0, ny + 1)
+            X, Y = np.meshgrid(xe, ye)
+            shading = "flat"
+        else:
+            shading = str(shading)
+        kw.setdefault("edgecolors", "none")
+        kw.setdefault("linewidth", 0.0)
+        kw.setdefault("antialiased", False)
+        kw.setdefault("snap", True)
+        artists = self.ax.pcolormesh(
+            X,
+            Y,
+            Z,
+            *args,
+            transform=self.ax.transAxes,
+            shading=shading,
+            **kw,
+        )
+        return _auto_clip(artists, self.ax, self._clip_path)
+
     def imshow(self, *args, **kwargs):
         kw = self._merge("imshow", kwargs)
         artists = self.ax.imshow(*args, **kw)

{jarvisplot-1.3.4 → jarvisplot-1.3.6}/jarvisplot/Figure/adapters_ternary.py

@@ -87,3 +87,24 @@ class TernaryAxesAdapter(StdAxesAdapter):
         return super().tricontourf(**kwargs)
         # else:
         #     raise ValueError("scatter() needs either (a,b,c) or (x,y) inputs")
+
+    def jpcontour(self, *args, **kwargs):
+        if {"left", "right", "bottom"}.issubset(kwargs.keys()):
+            x, y = self._lbr_to_xy(kwargs.pop("left"), kwargs.pop("right"), kwargs.pop("bottom"))
+            kwargs["x"] = x
+            kwargs["y"] = y
+        return super().jpcontour(*args, **kwargs)
+
+    def jpcontourf(self, *args, **kwargs):
+        if {"left", "right", "bottom"}.issubset(kwargs.keys()):
+            x, y = self._lbr_to_xy(kwargs.pop("left"), kwargs.pop("right"), kwargs.pop("bottom"))
+            kwargs["x"] = x
+            kwargs["y"] = y
+        return super().jpcontourf(*args, **kwargs)
+
+    def jpfield(self, *args, **kwargs):
+        if {"left", "right", "bottom"}.issubset(kwargs.keys()):
+            x, y = self._lbr_to_xy(kwargs.pop("left"), kwargs.pop("right"), kwargs.pop("bottom"))
+            kwargs["x"] = x
+            kwargs["y"] = y
+        return super().jpfield(*args, **kwargs)

{jarvisplot-1.3.4 → jarvisplot-1.3.6}/jarvisplot/Figure/colorbar_runtime.py

@@ -21,8 +21,7 @@ def axc_color_config(frame: Mapping[str, Any], cb_name: str = "axc") -> dict:
     """Return normalized color config for a named colorbar axis.
 
     Reads frame[cb_name].color.  A value of None or the string "auto" means
-    auto-range from data.  Falls back to legacy frame[cb_name].xscale /
-    yscale when 'scale' is absent from the color block.
+    auto-range from data.
     """
     out: dict[str, Any] = {}
     cb_cfg = frame.get(cb_name, {}) if isinstance(frame, Mapping) else {}
@@ -49,12 +48,6 @@ def axc_color_config(frame: Mapping[str, Any], cb_name: str = "axc") -> dict:
                 pass                 # non-numeric treated as auto
 
     scale = color_cfg.get("scale", None)
-    if scale is None:
-        is_h = axc_is_horizontal(frame, cb_name)
-        if is_h:
-            scale = cb_cfg.get("xscale", cb_cfg.get("yscale", None))
-        else:
-            scale = cb_cfg.get("yscale", cb_cfg.get("xscale", None))
     if isinstance(scale, str):
         scale = scale.strip().lower()
         if scale:
@@ -77,6 +70,27 @@ def _coerce_scalar(v) -> Optional[float]:
     return None
 
 
+def _is_numeric_color_source(spec) -> bool:
+    """Return True when a color spec looks like numeric scalar/mapping data.
+
+    We treat expression dictionaries and numeric array-likes as color sources,
+    but ignore plain strings such as literal colors or colormap names.
+    """
+    if spec is None:
+        return False
+    if isinstance(spec, str):
+        return False
+    if isinstance(spec, Mapping):
+        return "expr" in spec
+    try:
+        arr = np.asarray(spec, dtype=float)
+    except Exception:
+        return False
+    if arr.size == 0:
+        return False
+    return bool(np.isfinite(arr).any())
+
+
 def _resolve_norm(nv, *, vmin=None, vmax=None, logger=None):
     if nv is None:
         return None
@@ -126,20 +140,37 @@ def _resolve_norm(nv, *, vmin=None, vmax=None, logger=None):
 
 _COLORED_Z_METHODS = frozenset({
     "contour", "contourf", "tricontour", "tricontourf",
+    "jpcontour", "jpcontourf", "jpfield",
     "tripcolor", "tripcolor_axes",
     "pcolor", "pcolormesh", "imshow",
     "voronoi", "voronoif",
-    "grid_profile", "grid_profiling",
+    "grid_profile",
+})
+
+_CONTOUR_LIKE_METHODS = frozenset({
+    "contour", "contourf", "tricontour", "tricontourf",
+    "jpcontour", "jpcontourf",
 })
 
 
 def layer_uses_color(style: dict, coor: dict, method_key: str) -> bool:
     """Return True if this layer will need a colorbar."""
-    return (
-        bool(style.get("cmap"))
-        or ("c" in coor)
-        or (("z" in coor) and (method_key in _COLORED_Z_METHODS))
-    )
+    c_src = coor.get("c")
+    z_src = coor.get("z")
+
+    if _is_numeric_color_source(c_src):
+        return True
+    if method_key in _COLORED_Z_METHODS and _is_numeric_color_source(z_src):
+        return True
+
+    style_c = style.get("c")
+    style_z = style.get("z")
+    if _is_numeric_color_source(style_c):
+        return True
+    if method_key in _COLORED_Z_METHODS and _is_numeric_color_source(style_z):
+        return True
+
+    return False
 
 
 def collect_layer_color_range(df, coor: dict, style: dict, *, scale: str | None = None):
@@ -328,6 +359,24 @@ def collect_and_attach_colorbar(
       explicit frame.axc.color.vmin/vmax win; absent values fall back to
       the data-driven auto range.
     """
+    if not layer_uses_color(style, coor, method_key):
+        return style
+
+    # If the layer already declares an explicit contour color, do not inject a
+    # colormap.  Matplotlib treats `colors` and `cmap` as mutually exclusive for
+    # contour-style artists, and overlay layers often want a fixed line color
+    # while another layer owns the shared colorbar.
+    if method_key in _CONTOUR_LIKE_METHODS and (
+        "colors" in style or "color" in style
+    ):
+        s = dict(style)
+        s.pop("cmap", None)
+        s.pop("norm", None)
+        s.pop("vmin", None)
+        s.pop("vmax", None)
+        s.pop("mode", None)
+        return s
+
     axc = fig.axes.get(cb_name)
     if axc is None or not hasattr(axc, "_cb"):
         return style
@@ -377,7 +426,7 @@ def collect_and_attach_colorbar(
 
     # Contour levels (lazily generated on first contour layer, then reused)
     if (
-        method_key in ("contour", "contourf", "tricontour", "tricontourf")
+        method_key in ("contour", "contourf", "tricontour", "tricontourf", "jpcontour", "jpcontourf")
         and axc._cb.get("levels") is None
         and axc._cb.get("vmin") is not None
         and axc._cb.get("vmax") is not None