batplot 1.8.47__tar.gz → 1.8.48__tar.gz

{batplot-1.8.47 → batplot-1.8.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batplot
-Version: 1.8.47
+Version: 1.8.48
 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.47 → batplot-1.8.48}/batplot/__init__.py

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

{batplot-1.8.47 → batplot-1.8.48}/batplot/data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.8.48] - 2026-07-29
+- Bug fixes on session reload
+
+
 ## [1.8.47] - 2026-07-21
 - Added Batch Interactive mode, loading multiple saved .pkl sessions
   (must be the same type, e.g All are GC) to edit basic styles and

batplot-1.8.48/batplot/data/latest_release_notes.json

@@ -0,0 +1,7 @@
+{
+  "version": "1.8.48",
+  "custom_message": "- Bug fixes on session reload",
+  "update_notes": [
+    "- Bug fixes on session reload"
+  ]
+}

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/batch_figure_io.py

@@ -26,17 +26,20 @@ def save_standard_panel_figure(
     """Save a panel figure with SVG transparency handling (shared by batch export)."""
     path = ensure_exact_case_filename(path)
     _, ext = os.path.splitext(path)
-    owners: list[tuple[Any, Any | None]] = [(fig, getattr(fig, "patch", None)), (ax, getattr(ax, "patch", None))]
-    for extra in extra_axes:
-        if extra is not None:
-            owners.append((extra, getattr(extra, "patch", None)))
+    # Collect only real patches so restore never sees Optional patch/owner.
+    patch_owners: list[tuple[Any, Any]] = []
+    for owner in (fig, ax, *extra_axes):
+        if owner is None:
+            continue
+        patch = getattr(owner, "patch", None)
+        if patch is None:
+            continue
+        patch_owners.append((owner, patch))
 
     if ext.lower() == ".svg":
-        saved: list[tuple[Any, Any | None, Any]] = []
+        saved: list[tuple[Any, Any, Any]] = []
         try:
-            for owner, patch in owners:
-                if patch is None:
-                    continue
+            for owner, patch in patch_owners:
                 try:
                     fc = owner.get_facecolor() if owner is fig else patch.get_facecolor()
                 except Exception:

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/batch_menu_io.py

@@ -61,7 +61,7 @@ def batch_import_style(
     *,
     path_prompt: str,
     load_style: Callable[[str], Any],
-    apply_style: Callable[[Any, Any], None],
+    apply_style: Callable[[Any, Any], bool | None],
     prepare: Callable[[list[int]], None] | None = None,
     on_applied: Callable[[list[int], str], None] | None = None,
 ) -> list[int] | None:

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/common.py

@@ -34,7 +34,7 @@ class SyncUndoStacks:
         """True when at least one panel has more than the baseline snapshot (index 0)."""
         return any(len(s) > 1 for s in self._stacks)
 
-    def undo_all(self, restore_fn: Callable[[int, Any], None]) -> bool:
+    def undo_all(self, restore_fn: Callable[[int, Any], object]) -> bool:
         if not self.can_undo():
             print("No undo history.")
             return False

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/menu_cpc.py

@@ -16,7 +16,7 @@ from ..common.menus import run_legend_position_menu
 from ..common.spines import apply_frame_and_tick_widths, parse_frame_tick_widths
 from ..common.terminal import colorize_prompt, safe_input
 from ..cpc.colors import run_cpc_color_menu
-from ..cpc.interactive import _apply_style, _style_snapshot
+from ..cpc.style import _apply_style, _style_snapshot
 from ..cpc.labels import run_cpc_rename_menu
 from ..cpc.legend import (
     _rebuild_legend,

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/menu_ec.py

@@ -69,6 +69,7 @@ from .batch_menu_helpers import (
 )
 from .common import SyncUndoStacks, draw_panels, print_batch_header, set_all_panel_figure_titles
 from .ec_batch_helpers import (
+    default_ec_tick_state,
     ec_all_cycles,
     ec_apply_display_mode,
     ec_apply_nice_ticks,
@@ -76,6 +77,7 @@ from .ec_batch_helpers import (
     ec_normalize_file_data,
     ec_print_file_list_factory,
     ec_run_file_visibility_menu,
+    ec_tick_state_from_fig,
     edit_ref_then_sync,
     ensure_ec_fig_state,
     noop_snapshot,
@@ -87,44 +89,11 @@ from .load import EcPanel
 
 
 def _default_tick_state() -> dict:
-    return {
-        "bx": True,
-        "tx": False,
-        "ly": True,
-        "ry": False,
-        "mbx": False,
-        "mtx": False,
-        "mly": False,
-        "mry": False,
-    }
+    return default_ec_tick_state()
 
 
 def _tick_state_from_fig(fig) -> dict:
-    wasd = getattr(fig, "_ec_wasd_state", None)
-    if isinstance(wasd, dict):
-        top = wasd.get("top", {})
-        bot = wasd.get("bottom", {})
-        left = wasd.get("left", {})
-        right = wasd.get("right", {})
-        return {
-            "bx": bool(bot.get("ticks", True)),
-            "tx": bool(top.get("ticks", False)),
-            "ly": bool(left.get("ticks", True)),
-            "ry": bool(right.get("ticks", False)),
-            "mbx": bool(bot.get("minor", False)),
-            "mtx": bool(top.get("minor", False)),
-            "mly": bool(left.get("minor", False)),
-            "mry": bool(right.get("minor", False)),
-            "b_ticks": bool(bot.get("ticks", True)),
-            "t_ticks": bool(top.get("ticks", False)),
-            "l_ticks": bool(left.get("ticks", True)),
-            "r_ticks": bool(right.get("ticks", False)),
-            "b_labels": bool(bot.get("labels", True)),
-            "t_labels": bool(top.get("labels", False)),
-            "l_labels": bool(left.get("labels", True)),
-            "r_labels": bool(right.get("labels", False)),
-        }
-    return _default_tick_state()
+    return ec_tick_state_from_fig(fig)
 
 
 def _ec_batch_has_multi_file(panels: List[EcPanel]) -> bool:

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/menu_histo.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import os
-from typing import List
+from typing import Any, List
 
 from ..common.files import confirm_previous_path
 from ..common.menu_rendering import colorize_menu_item as _colorize_menu, print_menu_columns, prompt_menu_key
@@ -15,7 +15,7 @@ from ..histo.colors import run_histo_color_menu
 from ..histo.fonts import run_histo_font_menu, sync_histo_font_rcparams
 from ..histo.interactive import _export_style, _export_figure
 from ..histo.load import load_table
-from ..histo.plot import normalize_histo_title, refresh_histo_figure
+from ..histo.plot import HistoState, normalize_histo_title, refresh_histo_figure
 from ..histo.session import apply_histo_snapshot, apply_histo_style_snapshot, capture_histo_snapshot, save_histo_session
 from ..histo.toggles import run_histo_toggle_menu
 from ..histo.wizard import HistoSetup, run_histo_wizard
@@ -196,11 +196,13 @@ def run_histo_batch_menu(panels: List[HistoPanel]) -> None:
             continue
 
         if cmd == "l":
-            sync_targets = [(p.fig, p.ax, p.state) for p in panels[1:]]
+            line_sync_targets: list[tuple[Any, Any, HistoState]] = [
+                (p.fig, p.ax, p.state) for p in panels[1:]
+            ]
 
             def _apply_ref_line_style_to_all() -> None:
-                if sync_targets:
-                    sync_histo_line_style_from_reference(ref.ax, ref.state, sync_targets)
+                if line_sync_targets:
+                    sync_histo_line_style_from_reference(ref.ax, ref.state, line_sync_targets)
                 _refresh_all()
 
             run_histo_line_style_menu(

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/batch_session/operando_batch_helpers.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from typing import Callable, List, Sequence
+from typing import Callable, List, Sequence, TypeVar
 
 from ..common.spines import (
     apply_frame_and_tick_widths,
@@ -31,6 +31,8 @@ from .batch_menu_helpers import prompt_axis_limits
 from .common import SyncUndoStacks
 from .load import OperandoPanel
 
+PanelT = TypeVar("PanelT")
+
 
 def _cfg_signature(cfg: dict) -> str:
     try:
@@ -96,11 +98,11 @@ def _label_only_axes_geometry(axes_geom: dict | None) -> dict | None:
 
 
 def sync_style_from_ref(
-    ref: OperandoPanel,
-    panels: Sequence[OperandoPanel],
+    ref: PanelT,
+    panels: Sequence[PanelT],
     *,
-    capture_panel: Callable[[OperandoPanel], dict],
-    apply_cfg: Callable[[OperandoPanel, dict], bool],
+    capture_panel: Callable[[PanelT], dict],
+    apply_cfg: Callable[..., bool | None],
     include_geometry: bool = False,
 ) -> None:
     """Copy style (+ optional geometry) from the reference panel onto every other panel.
@@ -138,14 +140,14 @@ def sync_style_from_ref(
 
 
 def edit_ref_then_sync(
-    ref: OperandoPanel,
-    panels: List[OperandoPanel],
+    ref: PanelT,
+    panels: List[PanelT],
     *,
     undo: SyncUndoStacks,
-    capture_panel: Callable[[OperandoPanel], dict],
-    apply_cfg: Callable[[OperandoPanel, dict], bool],
+    capture_panel: Callable[[PanelT], dict],
+    apply_cfg: Callable[..., bool | None],
     draw_all: Callable[[], None],
-    edit_fn: Callable[[], None],
+    edit_fn: Callable[..., object],
     include_geometry: bool = False,
 ) -> None:
     """Run a ref-only editor, then push one undo point and sync style to all panels.

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/common/font_extras.py

@@ -133,11 +133,13 @@ def apply_font_extras_from_cfg(fig: Any, artists: Iterable[Any], cfg: dict[str,
     highlight = cfg.get("highlight")
     if highlight is not None:
         try:
-            alpha = float(cfg.get("highlight_alpha", DEFAULT_HIGHLIGHT_ALPHA))
+            alpha_raw = cfg.get("highlight_alpha", DEFAULT_HIGHLIGHT_ALPHA)
+            alpha = float(alpha_raw) if isinstance(alpha_raw, (int, float, str)) else DEFAULT_HIGHLIGHT_ALPHA
         except (TypeError, ValueError):
             alpha = DEFAULT_HIGHLIGHT_ALPHA
         try:
-            pad = float(cfg.get("highlight_pad", DEFAULT_HIGHLIGHT_PAD))
+            pad_raw = cfg.get("highlight_pad", DEFAULT_HIGHLIGHT_PAD)
+            pad = float(pad_raw) if isinstance(pad_raw, (int, float, str)) else DEFAULT_HIGHLIGHT_PAD
         except (TypeError, ValueError):
             pad = DEFAULT_HIGHLIGHT_PAD
         fc = cfg.get("highlight_fc", DEFAULT_HIGHLIGHT_FC)
@@ -193,7 +195,9 @@ def sync_font_rcparams_from_cfg(font_cfg: dict[str, object] | None) -> None:
     elif fam:
         set_font_family_defaults(fam, sans_serif_stack=True, update_mathtext=True)
     if font_cfg.get("size") is not None:
-        set_font_size_default(float(font_cfg["size"]))
+        size_raw = font_cfg["size"]
+        if isinstance(size_raw, (int, float, str)):
+            set_font_size_default(float(size_raw))
     if font_cfg.get("mathtext_fontset"):
         mpl.rcParams["mathtext.fontset"] = font_cfg["mathtext_fontset"]
 
@@ -244,11 +248,13 @@ def apply_session_font_cfg(
     if fam:
         apply_font_family_to_artists(collected, fam)
     if font_cfg.get("size") is not None:
-        sz = float(font_cfg["size"])
-        apply_font_size_to_artists(collected, sz)
-        for ax in axes:
-            if ax is not None:
-                sync_legend_title_fontsize(ax.get_legend(), sz)
+        size_raw = font_cfg["size"]
+        if isinstance(size_raw, (int, float, str)):
+            sz = float(size_raw)
+            apply_font_size_to_artists(collected, sz)
+            for ax in axes:
+                if ax is not None:
+                    sync_legend_title_fontsize(ax.get_legend(), sz)
     apply_font_extras_from_cfg(fig, collected, font_cfg)
 
 

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/common/menus.py

@@ -70,7 +70,7 @@ def run_font_menu(
     fonts: Optional[list[str]] = None,
     blank_exits: bool = True,
     get_current_weight: Callable[[], object] | None = None,
-    apply_weight: Callable[[str], None] | None = None,
+    apply_weight: Callable[[str], object] | None = None,
     get_current_highlight: Callable[[], bool] | None = None,
     get_highlight_style: Callable[[], dict] | None = None,
     apply_highlight_toggle: Callable[[], None] | None = None,
@@ -84,31 +84,33 @@ def run_font_menu(
     different artists to update (legends, duplicate titles, secondary axes).
     """
     fonts = fonts or DEFAULT_FONT_FAMILIES
-    has_weight = apply_weight is not None and get_current_weight is not None
-    has_highlight = (
-        apply_highlight_toggle is not None
-        and get_current_highlight is not None
-        and get_highlight_style is not None
-    )
     while True:
         status = f"family='{get_current_family()}', size={get_current_size()}"
-        if has_weight:
+        if get_current_weight is not None:
             status += f", weight={get_current_weight()}"
-        if has_highlight:
+        if get_current_highlight is not None:
             on = "on" if get_current_highlight() else "off"
             status += f", highlight={on}"
         print(f"\nFont (current: {status})")
         print("  " + colorize_menu("f: family"))
         print("  " + colorize_menu("s: size"))
-        if has_weight:
+        if apply_weight is not None and get_current_weight is not None:
             print("  " + colorize_menu("b: bold / weight"))
-        if has_highlight:
+        if (
+            apply_highlight_toggle is not None
+            and get_current_highlight is not None
+            and get_highlight_style is not None
+        ):
             print("  " + colorize_menu("h: text highlight (bbox behind labels)"))
         print("  " + colorize_menu("q: back"))
         keys = "f/s"
-        if has_weight:
+        if apply_weight is not None and get_current_weight is not None:
             keys += "/b"
-        if has_highlight:
+        if (
+            apply_highlight_toggle is not None
+            and get_current_highlight is not None
+            and get_highlight_style is not None
+        ):
             keys += "/h"
         keys += "/q"
         sub = safe_input(colorize_prompt(f"Font ({keys}): ")).strip().lower()
@@ -174,12 +176,14 @@ def run_font_menu(
                 process=_apply_size_choice,
             )
             continue
-        if sub == "b" and has_weight:
+        if sub == "b" and apply_weight is not None and get_current_weight is not None:
+            weight_getter = get_current_weight
+            weight_applier = apply_weight
 
             def _apply_weight_choice(choice: str) -> bool:
                 raw = choice.strip().lower()
                 if not raw:
-                    new_w = "normal" if str(get_current_weight()).lower() == "bold" else "bold"
+                    new_w = "normal" if str(weight_getter()).lower() == "bold" else "bold"
                 elif raw in ("bold", "b"):
                     new_w = "bold"
                 elif raw in ("normal", "n", "regular", "r"):
@@ -188,24 +192,32 @@ def run_font_menu(
                     print("Use bold, normal, or blank to toggle.")
                     return False
                 try:
-                    apply_weight(new_w)
+                    weight_applier(new_w)
                     print(f"Applied font weight: {new_w}")
                 except Exception as exc:
                     print(f"Error changing font weight: {exc}")
                 return True
 
             run_repeat_input_loop(
-                prompt=lambda: f"Font weight (current: {get_current_weight()}, bold/normal/blank=toggle, q=back): ",
+                prompt=lambda: f"Font weight (current: {weight_getter()}, bold/normal/blank=toggle, q=back): ",
                 safe_input=safe_input,
                 colorize_prompt=colorize_prompt,
                 process=_apply_weight_choice,
                 cancel_on_blank=False,
             )
             continue
-        if sub == "h" and has_highlight:
+        if (
+            sub == "h"
+            and apply_highlight_toggle is not None
+            and get_current_highlight is not None
+            and get_highlight_style is not None
+        ):
+            hl_toggle = apply_highlight_toggle
+            hl_get = get_current_highlight
+            hl_style = get_highlight_style
             while True:
-                st = get_highlight_style()
-                on = "on" if get_current_highlight() else "off"
+                st = hl_style()
+                on = "on" if hl_get() else "off"
                 print(f"\nText highlight (current: {on}, face={st.get('fc', 'white')}, alpha={st.get('alpha', 0.85):g}, pad={st.get('pad', 0.2):g})")
                 print("  " + colorize_menu("t: toggle on/off"))
                 print("  " + colorize_menu("c: face color (e.g. white, #f8f8f8)"))
@@ -217,29 +229,31 @@ def run_font_menu(
                     break
                 if hsub == "t":
                     try:
-                        apply_highlight_toggle()
-                        print(f"Text highlight {'on' if get_current_highlight() else 'off'}.")
+                        hl_toggle()
+                        print(f"Text highlight {'on' if hl_get() else 'off'}.")
                     except Exception as exc:
                         print(f"Error toggling highlight: {exc}")
                     continue
                 if hsub == "c" and apply_highlight_facecolor is not None:
+                    hl_facecolor = apply_highlight_facecolor
 
                     def _apply_hl_color(spec: str) -> bool:
                         try:
-                            apply_highlight_facecolor(spec)
+                            hl_facecolor(spec)
                             print(f"Highlight face color set to {spec}.")
                         except Exception as exc:
                             print(f"Error: {exc}")
                         return True
 
                     run_repeat_input_loop(
-                        prompt=lambda: f"Highlight face color (current: {get_highlight_style().get('fc', 'white')}, q=back): ",
+                        prompt=lambda: f"Highlight face color (current: {hl_style().get('fc', 'white')}, q=back): ",
                         safe_input=safe_input,
                         colorize_prompt=colorize_prompt,
                         process=_apply_hl_color,
                     )
                     continue
                 if hsub == "a" and apply_highlight_alpha is not None:
+                    hl_alpha = apply_highlight_alpha
 
                     def _apply_hl_alpha(raw: str) -> bool:
                         try:
@@ -251,20 +265,21 @@ def run_font_menu(
                             print("Alpha must be between 0 and 1.")
                             return False
                         try:
-                            apply_highlight_alpha(val)
+                            hl_alpha(val)
                             print(f"Highlight alpha set to {val:g}.")
                         except Exception as exc:
                             print(f"Error: {exc}")
                         return True
 
                     run_repeat_input_loop(
-                        prompt=lambda: f"Highlight alpha (current: {get_highlight_style().get('alpha', 0.85):g}, q=back): ",
+                        prompt=lambda: f"Highlight alpha (current: {hl_style().get('alpha', 0.85):g}, q=back): ",
                         safe_input=safe_input,
                         colorize_prompt=colorize_prompt,
                         process=_apply_hl_alpha,
                     )
                     continue
                 if hsub == "p" and apply_highlight_pad is not None:
+                    hl_pad = apply_highlight_pad
 
                     def _apply_hl_pad(raw: str) -> bool:
                         try:
@@ -276,14 +291,14 @@ def run_font_menu(
                             print("Pad must be non-negative.")
                             return False
                         try:
-                            apply_highlight_pad(val)
+                            hl_pad(val)
                             print(f"Highlight pad set to {val:g}.")
                         except Exception as exc:
                             print(f"Error: {exc}")
                         return True
 
                     run_repeat_input_loop(
-                        prompt=lambda: f"Highlight pad (current: {get_highlight_style().get('pad', 0.2):g}, q=back): ",
+                        prompt=lambda: f"Highlight pad (current: {hl_style().get('pad', 0.2):g}, q=back): ",
                         safe_input=safe_input,
                         colorize_prompt=colorize_prompt,
                         process=_apply_hl_pad,

{batplot-1.8.47 → batplot-1.8.48}/batplot/plot_modes/common/palettes.py

@@ -189,7 +189,12 @@ def sample_palette_colors(
     except Exception:
         ensure_colormap("viridis")
         cmap = cmap_getter("viridis")
-    if prefer_listed_colors and hasattr(cmap, "colors") and cmap.colors is not None:
+    if (
+        prefer_listed_colors
+        and cmap is not None
+        and hasattr(cmap, "colors")
+        and getattr(cmap, "colors", None) is not None
+    ):
         colors = cmap.colors
         out = []
         for i in range(n):