batplot 1.8.44__tar.gz → 1.8.45__tar.gz

{batplot-1.8.44 → batplot-1.8.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batplot
-Version: 1.8.44
+Version: 1.8.45
 Summary: Interactive plotting tool for material science (1D plot) and electrochemistry (GC, CV, dQ/dV, CPC, operando) with batch processing
 Author-email: Tian Dai <tianda@uio.no>
 License: MIT License

{batplot-1.8.44 → batplot-1.8.45}/batplot/__init__.py

@@ -7,7 +7,7 @@ import importlib.abc
 import importlib.machinery
 import sys
 
-__version__ = "1.8.44"
+__version__ = "1.8.45"
 
 
 _LEGACY_MODULE_ALIASES = {

batplot-1.8.45/batplot/_mpl_backend.py

@@ -0,0 +1,231 @@
+"""Matplotlib backend selection for batplot CLI and interactive sessions.
+
+Imported early from :mod:`batplot.cli` so pytest/CI on Windows never fall back
+to Tk when ``MPLBACKEND=Agg`` is set explicitly in the environment.
+
+When the user has not set ``MPLBACKEND``, we start on Agg for safe imports but
+may switch to a GUI backend before opening interactive windows (``.pkl`` reload,
+``--gc --i``, ``--canvas``, etc.).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import sys
+
+_USER_SET_MPLBACKEND = "MPLBACKEND" in os.environ
+_DEFAULT_BACKEND = os.environ.get("MPLBACKEND", "Agg")
+
+import matplotlib as _mpl
+
+_mpl.use(_DEFAULT_BACKEND, force=True)
+
+_INTERACTIVE_BACKENDS = frozenset(
+    {
+        "macosx",
+        "tkagg",
+        "qt5agg",
+        "qt4agg",
+        "qtagg",
+        "wxagg",
+        "gtk3agg",
+        "gtk4agg",
+        "wx",
+        "qt",
+        "gtk",
+        "gtk3",
+        "gtk4",
+    }
+)
+
+
+def _is_noninteractive_backend(name: str | None) -> bool:
+    if not isinstance(name, str):
+        return False
+    low = name.lower()
+    if low in _INTERACTIVE_BACKENDS:
+        return False
+    return ("agg" in low) or ("inline" in low) or (low in {"pdf", "ps", "svg", "template"})
+
+
+def is_interactive_backend() -> bool:
+    """Return True when the active Matplotlib backend can open a GUI window."""
+    try:
+        return not _is_noninteractive_backend(_mpl.get_backend())
+    except Exception:
+        return False
+
+
+def _headless_context() -> bool:
+    """True when batplot must stay on a non-interactive backend (CI/pytest)."""
+    if os.environ.get("BATPLOT_HEADLESS", "").lower() in ("1", "true", "yes"):
+        return True
+    if os.environ.get("CI", "").lower() in ("1", "true", "yes"):
+        return True
+    if os.environ.get("PYTEST_CURRENT_TEST"):
+        return True
+    if "pytest" in sys.modules:
+        return True
+    return False
+
+
+def running_headless() -> bool:
+    """True under pytest, CI, or when ``BATPLOT_HEADLESS`` is set."""
+    return _headless_context()
+
+
+def wants_interactive_window(args) -> bool:
+    """Return True when this CLI invocation should open an interactive figure."""
+    if getattr(args, "all", None) is not None:
+        return False
+    files = getattr(args, "files", None) or []
+    if any(str(f).lower().endswith(".pkl") for f in files):
+        return True
+    if getattr(args, "canvas", False):
+        return True
+    if getattr(args, "interactive", False):
+        return True
+    # Headless export: mode flags with --out/--savefig do not need a GUI window.
+    if getattr(args, "savefig", False) or getattr(args, "out", None):
+        return False
+    for attr in ("operando", "contour", "gc", "cv", "dqdv", "cpc", "epc"):
+        if getattr(args, attr, False):
+            return True
+    return False
+
+
+def _should_respect_env_agg() -> bool:
+    """Keep Agg when the environment requested it and we are in headless context."""
+    if not _USER_SET_MPLBACKEND:
+        return False
+    env_be = os.environ.get("MPLBACKEND")
+    if not env_be or not _is_noninteractive_backend(env_be):
+        return False
+    return _headless_context()
+
+
+def _has_qt_bindings() -> bool:
+    for mod in ("PyQt6", "PyQt5", "PySide6", "PySide2"):
+        if importlib.util.find_spec(mod) is not None:
+            return True
+    return False
+
+
+def _gui_backend_order() -> list[str]:
+    if sys.platform == "darwin":
+        return ["MacOSX", "TkAgg", "QtAgg"]
+    if sys.platform.startswith("win"):
+        return ["TkAgg", "QtAgg"]
+    return ["TkAgg", "QtAgg", "Gtk4Agg", "Gtk3Agg"]
+
+
+def _backend_can_be_tried(name: str) -> bool:
+    if name == "TkAgg":
+        return importlib.util.find_spec("tkinter") is not None
+    if name == "QtAgg":
+        return _has_qt_bindings()
+    return True
+
+
+def _backend_setup_tips() -> list[str]:
+    if sys.platform == "darwin":
+        return [
+            "  export MPLBACKEND=MacOSX   # built-in macOS backend",
+            "  export MPLBACKEND=TkAgg    # if Tk is available",
+            "  export MPLBACKEND=QtAgg    # if PyQt/PySide is installed",
+        ]
+    if sys.platform.startswith("win"):
+        return [
+            "  set MPLBACKEND=TkAgg        # cmd, if Tk is available",
+            '  $env:MPLBACKEND="TkAgg"   # PowerShell',
+            "  set MPLBACKEND=QtAgg        # if PyQt/PySide is installed",
+        ]
+    return [
+        "  export MPLBACKEND=TkAgg     # if python3-tk is installed",
+        "  export MPLBACKEND=QtAgg     # if PyQt/PySide is installed",
+        "  export MPLBACKEND=Gtk3Agg  # if GTK3 bindings are installed",
+    ]
+
+
+def ensure_gui_backend(args=None) -> bool:
+    """Switch from Agg to a GUI backend when an interactive window is expected.
+
+    Returns True when the active backend is interactive (or was switched to one).
+    Honors ``MPLBACKEND=Agg`` only under pytest/CI; interactive CLI use (``--i``,
+    ``.pkl`` reload) overrides an inherited Agg default from conda/shell profiles.
+    """
+    if args is not None and not wants_interactive_window(args):
+        return is_interactive_backend()
+
+    if _should_respect_env_agg():
+        return False
+
+    if _USER_SET_MPLBACKEND:
+        env_be = os.environ.get("MPLBACKEND")
+        if env_be and not _is_noninteractive_backend(env_be):
+            return True
+
+    if is_interactive_backend():
+        return True
+
+    for cand in _gui_backend_order():
+        if not _backend_can_be_tried(cand):
+            continue
+        try:
+            _mpl.use(cand, force=True)
+            if is_interactive_backend():
+                return True
+        except Exception:
+            continue
+    return False
+
+
+def warn_if_noninteractive(context: str = "interactive menu") -> bool:
+    """Print a helpful message when the backend cannot show a window."""
+    if is_interactive_backend():
+        return True
+    try:
+        backend = _mpl.get_backend()
+    except Exception:
+        backend = "unknown"
+    print(f"Matplotlib backend '{backend}' is non-interactive; a window cannot be shown.")
+    print("Tips: unset MPLBACKEND or set a GUI backend:")
+    for line in _backend_setup_tips():
+        print(line)
+    if context:
+        print(f"The {context} requires an interactive backend.")
+    return False
+
+
+def require_interactive_display(
+    args=None,
+    *,
+    context: str = "interactive menu",
+    export_hint: str | None = "Or run without --interactive and use --out to save the figure.",
+) -> bool:
+    """Ensure a GUI backend, warn if unavailable, return True when display is possible."""
+    ensure_gui_backend(args)
+    if is_interactive_backend():
+        return True
+    warn_if_noninteractive(context)
+    if export_hint:
+        print(export_hint)
+    return False
+
+
+def show_figure_if_possible(args=None, *, block: bool = False) -> bool:
+    """Show the current figure when the backend supports windows."""
+    ensure_gui_backend(args)
+    if not is_interactive_backend():
+        if args is not None and not (getattr(args, "savefig", False) or getattr(args, "out", None)):
+            try:
+                backend = _mpl.get_backend()
+            except Exception:
+                backend = "unknown"
+            print(f"Matplotlib backend '{backend}' is non-interactive; use --out to save the figure.")
+        return False
+    import matplotlib.pyplot as plt
+
+    plt.show(block=block)
+    return True

{batplot-1.8.44 → batplot-1.8.45}/batplot/batch.py

@@ -6,9 +6,10 @@ import os
 import json
 from typing import Tuple, cast
 
-import matplotlib.cm as cm  # type: ignore[import]
-import numpy as np  # type: ignore[import]
 import matplotlib.pyplot as plt  # type: ignore[import]
+import numpy as np  # type: ignore[import]
+
+from .color_utils import get_colormap
 
 from .readers import (
     read_gr_file,
@@ -961,9 +962,11 @@ def batch_process_ec(directory: str, args):
             
             if remaining <= 60:
                 # Use tab20, tab20b, tab20c for categorical colors (up to 70 total)
-                tab20 = cm.get_cmap('tab20')
-                tab20b = cm.get_cmap('tab20b')
-                tab20c = cm.get_cmap('tab20c')
+                tab20 = get_colormap('tab20')
+                tab20b = get_colormap('tab20b')
+                tab20c = get_colormap('tab20c')
+                if tab20 is None or tab20b is None or tab20c is None:
+                    return colors[:n_colors]
                 
                 for i in range(remaining):
                     cmap_idx = i % 60
@@ -987,7 +990,9 @@ def batch_process_ec(directory: str, args):
                 colors_per_map = (remaining + len(cmaps) - 1) // len(cmaps)
                 
                 for cmap_name in cmaps:
-                    cmap = cm.get_cmap(cmap_name)
+                    cmap = get_colormap(cmap_name)
+                    if cmap is None:
+                        continue
                     # Sample evenly across the colormap
                     for i in range(colors_per_map):
                         if len(colors) >= n_colors:
@@ -1117,7 +1122,7 @@ def batch_process_ec(directory: str, args):
                 cycle_colors = get_color_palette(len(cycles_present))
                 
                 for idx, cyc in enumerate(cycles_present):  # Plot all cycles
-                    mask = (cyc_int == cyc)
+                    mask = np.asarray(cyc_int == cyc, dtype=bool)
                     mask_idx = np.where(mask)[0]
                     if mask_idx.size >= 2:
                         color = cycle_colors[idx]
@@ -1265,11 +1270,11 @@ def batch_process_ec(directory: str, args):
                                 mask_c = (cyc_int_raw == cyc) & charge_mask
                                 mask_d = (cyc_int_raw == cyc) & discharge_mask
                                 if np.count_nonzero(mask_c) >= 2:
-                                    en_c = float(np.trapz(voltage[mask_c], cap_x[mask_c]))
+                                    en_c = float((getattr(np, "trapezoid", None) or np.trapz)(voltage[mask_c], cap_x[mask_c]))
                                 else:
                                     en_c = 0.0
                                 if np.count_nonzero(mask_d) >= 2:
-                                    en_d = float(np.trapz(voltage[mask_d], cap_x[mask_d]))
+                                    en_d = float((getattr(np, "trapezoid", None) or np.trapz)(voltage[mask_d], cap_x[mask_d]))
                                 else:
                                     en_d = 0.0
                                 en_charge.append(en_c)
@@ -1300,11 +1305,11 @@ def batch_process_ec(directory: str, args):
                                     val_d = np.max(cap_x[mask_d]) if np.any(mask_d) else 0.0
                                 else:
                                     if np.count_nonzero(mask_c) >= 2:
-                                        val_c = float(np.trapz(voltage[mask_c], cap_x[mask_c]))
+                                        val_c = float((getattr(np, "trapezoid", None) or np.trapz)(voltage[mask_c], cap_x[mask_c]))
                                     else:
                                         val_c = 0.0
                                     if np.count_nonzero(mask_d) >= 2:
-                                        val_d = float(np.trapz(voltage[mask_d], cap_x[mask_d]))
+                                        val_d = float((getattr(np, "trapezoid", None) or np.trapz)(voltage[mask_d], cap_x[mask_d]))
                                     else:
                                         val_d = 0.0
                                 cap_charge_list.append(val_c)

{batplot-1.8.44 → batplot-1.8.45}/batplot/batplot.py

@@ -421,6 +421,10 @@ def batplot_main() -> int:  # type: ignore
         print("Use 'batplot --v' for version and release info, 'batplot --h' for CLI help, or 'batplot --m' to open the user manual.")
         return 0  # Exit successfully (not an error, just nothing to do)
 
+    from ._mpl_backend import ensure_gui_backend
+
+    ensure_gui_backend(args)
+
     # ====================================================================
     # STEP 3: ROUTE TO APPROPRIATE MODE HANDLER
     # ====================================================================
@@ -482,64 +486,6 @@ def batplot_main() -> int:  # type: ignore
     """
 
 
-    # Ensure an interactive (GUI) backend when a window is expected (interactive mode or operando/GC plots)
-    def _ensure_gui_backend_for_interactive():
-        try:
-            argv = sys.argv
-        except Exception:
-            argv = []
-        # Trigger if interactive is requested OR when operando/GC plotting likely calls show()
-        wants_interactive = any(flag in argv for flag in ("--interactive",))
-        wants_interactive = wants_interactive or ("--operando" in argv or "--contour" in argv)
-        wants_interactive = wants_interactive or ("--gc" in argv)
-        if not wants_interactive:
-            return
-        # If MPLBACKEND is set to a GUI backend, respect it; if it's non-interactive, we'll override below
-        env_be = os.environ.get("MPLBACKEND")
-        if env_be:
-            low = env_be.lower()
-            if low in {"macosx","tkagg","qtagg"}:
-                return
-        try:
-            be = _mpl.get_backend()
-        except Exception:
-            be = None
-        def _is_noninteractive(name):
-            if not isinstance(name, str):
-                return False
-            low = name.lower()
-            return ("agg" in low) or ("inline" in low) or (low in {"pdf","ps","svg","template"})
-        if not _is_noninteractive(be):
-            return
-        # Try GUI backends in order of likelihood
-        candidates = [
-            ("darwin", ["MacOSX", "TkAgg", "QtAgg"]),
-            ("win", ["TkAgg", "QtAgg"]),
-            ("other", ["TkAgg", "QtAgg"]),
-        ]
-        plat = sys.platform
-        if plat == "darwin":
-            order = candidates[0][1]
-        elif plat.startswith("win"):
-            order = candidates[1][1]
-        else:
-            order = candidates[2][1]
-        for cand in order:
-            try:
-                if cand == "TkAgg":
-                    if importlib.util.find_spec("tkinter") is None:
-                        continue
-                elif cand == "QtAgg":
-                    if (importlib.util.find_spec("PyQt5") is None) and (importlib.util.find_spec("PySide6") is None):
-                        continue
-                # MacOSX: attempt; will fail on non-framework builds
-                _mpl.use(cand, force=True)
-                break
-            except Exception:
-                continue
-
-    _ensure_gui_backend_for_interactive()
-
     # Set global default font
     plt.rcParams.update({
         'font.family': 'sans-serif',
@@ -550,10 +496,6 @@ def batplot_main() -> int:  # type: ignore
         'font.size': 16
     })
 
-    # Parse CLI arguments early; many top-level branches depend on args
-    args = _bp_parse_args()
-
-
     """
     Note: CIF parsing and simulation helpers now come from batplot.cif.
     This file defers to simulate_cif_pattern_Q and cif_reflection_positions

{batplot-1.8.44 → batplot-1.8.45}/batplot/canvas_interactive.py

@@ -25,6 +25,7 @@ from matplotlib.patches import Rectangle
 from matplotlib.text import Text
 
 from .session import load_ec_session, load_operando_session, load_cpc_session, load_xy_session
+from ._mpl_backend import ensure_gui_backend
 from .plot_modes.electrochem.interactive import electrochem_interactive_menu
 from .plot_modes.xy.interactive import interactive_menu, normalize_xy_menu_kwargs
 from .utils import _confirm_overwrite
@@ -290,6 +291,7 @@ def _normalize_loaded_annotation(raw: Any, base_dir: Optional[str]) -> Optional[
 
 
 def run_canvas_mode(pkl_paths: List[str]) -> None:
+    ensure_gui_backend(None)
     pkl_paths, loaded_positions, raw_annotations, manifest_base_dir = _expand_canvas_paths(pkl_paths)
 
     if not pkl_paths:
@@ -465,7 +467,7 @@ def run_canvas_mode(pkl_paths: List[str]) -> None:
                     ann_runtime.append((None, None))
                     continue
                 try:
-                    ax_img = fig_canvas.add_axes([l, b, w, h], facecolor='none')
+                    ax_img = fig_canvas.add_axes((l, b, w, h), facecolor='none')
                     ax_img.set_zorder(15)
                     if arr.ndim == 2:
                         ax_img.imshow(arr, cmap='gray', aspect='auto', origin='upper')
@@ -724,7 +726,7 @@ def run_canvas_mode(pkl_paths: List[str]) -> None:
                             continue
                         try:
                             arr_e = mpl_imread(ip)
-                            ax_e = fig_exp.add_axes([l, b, w, h], facecolor='none')
+                            ax_e = fig_exp.add_axes((l, b, w, h), facecolor='none')
                             ax_e.set_zorder(15)
                             if arr_e.ndim == 2:
                                 ax_e.imshow(arr_e, cmap='gray', aspect='auto', origin='upper')

{batplot-1.8.44 → batplot-1.8.45}/batplot/cli.py

@@ -14,6 +14,8 @@ from __future__ import annotations
 import sys
 from typing import Optional
 
+from . import _mpl_backend  # noqa: F401  — set Agg before pyplot loads
+
 
 def main(argv: Optional[list] = None) -> int:
 	"""

{batplot-1.8.44 → batplot-1.8.45}/batplot/color_utils.py

@@ -41,7 +41,7 @@ This is useful when you want the color order flipped.
 
 from __future__ import annotations
 
-from typing import List, Optional, Sequence
+from typing import List, Optional, Sequence, cast
 
 import matplotlib.pyplot as plt  # type: ignore[import]
 from matplotlib import colors as mcolors  # type: ignore[import]
@@ -171,7 +171,9 @@ def ensure_colormap(name: Optional[str]) -> bool:
     # STEP 4: Final fallback - try to get it directly from matplotlib
     # This handles any other matplotlib-compatible colormap
     try:
-        plt.get_cmap(base_lower)
+        from matplotlib import colormaps as mpl_colormaps
+
+        _ = mpl_colormaps[base_lower]
         return True
     except Exception:
         return False
@@ -201,7 +203,7 @@ def get_colormap(name: Optional[str]) -> Optional[Colormap]:
         if callable(registry_get):
             for candidate in candidates:
                 try:
-                    return registry_get(candidate)
+                    return cast(Colormap, registry_get(candidate))
                 except Exception:
                     pass
         for candidate in candidates:
@@ -313,24 +315,7 @@ def palette_preview(name: str, steps: int = 8) -> str:
     ensure_colormap(name)
     
     # Try to get the colormap from matplotlib
-    cmap: Optional[Colormap]
-    try:
-        cmap = plt.get_cmap(name)
-    except Exception:
-        cmap = None
-        # Fallback: try cmcrameri if it's a batlow variant
-        lower = name.lower()
-        if lower.startswith('batlow'):
-            try:
-                import cmcrameri.cm as cmc  # type: ignore[import]
-                if hasattr(cmc, lower):
-                    cmap = getattr(cmc, lower)
-                elif hasattr(cmc, 'batlow'):
-                    cmap = getattr(cmc, 'batlow')
-            except Exception:
-                return ""
-        else:
-            return ""
+    cmap: Optional[Colormap] = get_colormap(name)
 
     # If we still don't have a colormap, bail out
     if cmap is None:

{batplot-1.8.44 → batplot-1.8.45}/batplot/converters.py

@@ -271,6 +271,7 @@ def convert_xrd_data(
         
         # Perform conversion based on type
         if conversion_type == "wavelength_to_wavelength":
+            assert from_wl is not None and to_wl is not None
             # Step 1: Convert 2θ (from_wl) → Q
             theta_rad = np.radians(x / 2)  # Convert 2θ to θ in radians
             q = 4 * np.pi * np.sin(theta_rad) / from_wl
@@ -287,12 +288,14 @@ def convert_xrd_data(
             output_ext = os.path.splitext(fname)[1]  # Keep original extension
             
         elif conversion_type == "wavelength_to_q":
+            assert from_wl is not None
             # Convert 2θ → Q
             theta_rad = np.radians(x / 2)  # Convert 2θ to θ in radians
             x_new = 4 * np.pi * np.sin(theta_rad) / from_wl
             output_ext = ".qye"
             
         elif conversion_type == "q_to_wavelength":
+            assert to_wl is not None
             # Convert Q → 2θ
             # Q = 4π sin(θ) / λ, so sin(θ) = Q × λ / (4π)
             sin_theta = x * to_wl / (4 * np.pi)

{batplot-1.8.44 → batplot-1.8.45}/batplot/data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.8.45] - 2026-06-30
+- Bug fixes with backend setting
+
+
 ## [1.8.44] - 2026-06-25
 - Bug fixes
 

{batplot-1.8.44 → batplot-1.8.45}/batplot/dev_upgrade.py

@@ -598,7 +598,7 @@ def _required_package_data_files(project_root: Path) -> list[str]:
         return []
     rel_paths: list[str] = []
     for item in re.findall(r'"([^"]+)"', package_match.group("items")):
-        rel_paths.append(f"batplot/{item.replace('\\\\', '/')}")
+        rel_paths.append("batplot/" + item.replace("\\", "/"))
     return sorted(set(rel_paths))
 
 

{batplot-1.8.44 → batplot-1.8.45}/batplot/plot_modes/common/palettes.py

@@ -9,12 +9,14 @@ keeps its own established defaults.
 
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Iterable, List, Sequence, Tuple
+from typing import Any, Callable, Dict, Iterable, List, Sequence, Tuple, cast
 
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.colors as mcolors
 
+from ...color_utils import get_colormap
+
 
 TAB10_HEX: Tuple[str, ...] = (
     "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
@@ -181,7 +183,7 @@ def sample_palette_colors(
     if not ensure_colormap(name):
         name = "viridis"
         ensure_colormap(name)
-    cmap_getter = get_cmap or plt.get_cmap
+    cmap_getter = get_cmap or get_colormap
     try:
         cmap = cmap_getter(name)
     except Exception:
@@ -195,7 +197,7 @@ def sample_palette_colors(
             if isinstance(rgb, tuple) and len(rgb) >= 3:
                 out.append(mcolors.rgb2hex(rgb[:3]))
             else:
-                out.append(mcolors.to_hex(rgb))
+                out.append(mcolors.to_hex(cast(Any, rgb)))
         return out
     sampled = sample_colormap(cmap, n, single=single, pair=pair, span=span)
     return [mcolors.rgb2hex(color[:3]) for color in sampled]

{batplot-1.8.44 → batplot-1.8.45}/batplot/plot_modes/common/spines.py

@@ -7,7 +7,7 @@ application that is identical across modes.
 
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Iterable, Mapping, MutableMapping, Optional, Sequence
+from typing import Any, Callable, Dict, Iterable, Mapping, MutableMapping, Optional, Sequence, cast
 
 import matplotlib.pyplot as plt  # type: ignore[import-untyped]
 from matplotlib.ticker import (  # type: ignore[import-untyped]
@@ -340,7 +340,7 @@ def current_tick_width(axis_obj: Any, which: str) -> Optional[float]:
         width = tick_kw.get("width")
         if width is None:
             axis_name = getattr(axis_obj, "axis_name", "x")
-            width = plt.rcParams.get(f"{axis_name}tick.{which}.width")
+            width = plt.rcParams.get(cast(Any, f"{axis_name}tick.{which}.width"))
         return float(width) if width is not None else None
     except Exception:
         return None

{batplot-1.8.44 → batplot-1.8.45}/batplot/plot_modes/cpc/colors.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-import matplotlib.cm as cm  # type: ignore[import]
 from matplotlib.colors import hsv_to_rgb, rgb_to_hsv, to_rgb  # type: ignore[import]
 
 from ...color_utils import (
     color_block,
     ensure_colormap,
+    get_colormap,
     get_user_color_list,
     manage_user_colors,
     palette_preview,
@@ -41,7 +41,7 @@ def cpc_palette_color(name: str, idx: int = 0, total: int = 1):
         name,
         max(total, 1),
         ensure_colormap=ensure_colormap,
-        get_cmap=cm.get_cmap,
+        get_cmap=get_colormap,
         prefer_listed_colors=True,
         pair=(0.15, 0.85),
         span=(0.08, 0.88),
@@ -59,7 +59,8 @@ def parse_file_range_palette(tokens: list[str], n_files: int, palette_opts: list
     try:
         if not ensure_colormap(last):
             raise ValueError(last)
-        cm.get_cmap(last)
+        if get_colormap(last) is None:
+            raise ValueError(last)
         palette = last
     except Exception:
         if last.isdigit() and 1 <= int(last) <= len(palette_opts):

{batplot-1.8.44 → batplot-1.8.45}/batplot/plot_modes/cpc/interactive.py

@@ -33,7 +33,7 @@ This is useful for comparing different battery cells, materials, or conditions.
 """
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 import json
 import os
 import sys
@@ -226,7 +226,7 @@ def _style_snapshot(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_data=Non
             if width is None:
                 axis_name = getattr(axis_obj, 'axis_name', 'x')
                 rc_key = f"{axis_name}tick.{which}.width"
-                width = plt.rcParams.get(rc_key)
+                width = plt.rcParams.get(cast(Any, rc_key))
             if width is not None:
                 return float(width)
         except Exception:

{batplot-1.8.44 → batplot-1.8.45}/batplot/plot_modes/cpc/legend.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, Optional, cast
 
 import numpy as np
 import matplotlib.patches as mpatches  # type: ignore[import]
@@ -116,7 +116,7 @@ def _color_of(artist):
                     return color[0]
             if color is not None:
                 try:
-                    return to_hex(color)
+                    return to_hex(cast(Any, color))
                 except Exception:
                     return color
         if hasattr(artist, "get_facecolors"):