batplot 1.8.5__py3-none-any.whl → 1.8.6__py3-none-any.whl

batplot/modes.py

@@ -151,7 +151,8 @@ def handle_cv_mode(args) -> int:
         # Configure fonts to match other modes (consistent across batplot)
         plt.rcParams.update({
             'font.family': 'sans-serif',
-            'font.sans-serif': ['Arial', 'DejaVu Sans', 'Helvetica', 'STIXGeneral', 'Liberation Sans', 'Arial Unicode MS'],
+            # Prefer DejaVu Sans first for full Unicode coverage (subscripts, etc.)
+            'font.sans-serif': ['DejaVu Sans', 'Arial', 'Helvetica', 'STIXGeneral', 'Liberation Sans', 'Arial Unicode MS'],
             'mathtext.fontset': 'dejavusans',
             'font.size': 16
         })
@@ -280,8 +281,8 @@ def handle_cv_mode(args) -> int:
             ax.set_xlabel('Current (mA)', labelpad=8.0)
             ax.set_ylabel('Voltage (V)', labelpad=8.0)
         else:
-        ax.set_xlabel('Voltage (V)', labelpad=8.0)
-        ax.set_ylabel('Current (mA)', labelpad=8.0)
+            ax.set_xlabel('Voltage (V)', labelpad=8.0)
+            ax.set_ylabel('Current (mA)', labelpad=8.0)
         legend = ax.legend(title='Cycle')
         legend.get_title().set_fontsize('medium')
         # Adjust margins to prevent label clipping
@@ -642,8 +643,8 @@ def handle_gc_mode(args) -> int:
                         ln_c, = ax.plot(y_b, x_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
                                         linewidth=2.0, label=str(cyc), alpha=0.8)
                     else:
-                    ln_c, = ax.plot(x_b, y_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
-                                    linewidth=2.0, label=str(cyc), alpha=0.8)
+                        ln_c, = ax.plot(x_b, y_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
+                                        linewidth=2.0, label=str(cyc), alpha=0.8)
                 else:
                     ln_c = None
                 mask_d = (cyc_int == cyc) & discharge_mask
@@ -656,8 +657,8 @@ def handle_gc_mode(args) -> int:
                         ln_d, = ax.plot(yd_b, xd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
                                         linewidth=2.0, label=lbl, alpha=0.8)
                     else:
-                    ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
-                                    linewidth=2.0, label=lbl, alpha=0.8)
+                        ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
+                                        linewidth=2.0, label=lbl, alpha=0.8)
                 else:
                     ln_d = None
                 cycle_lines[cyc] = {"charge": ln_c, "discharge": ln_d}
@@ -690,8 +691,8 @@ def handle_gc_mode(args) -> int:
                         ln_d, = ax.plot(yd_b, xd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
                                         linewidth=2.0, label=lbl, alpha=0.8)
                     else:
-                    ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
-                                    linewidth=2.0, label=lbl, alpha=0.8)
+                        ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
+                                        linewidth=2.0, label=lbl, alpha=0.8)
                 cycle_lines[cyc] = {"charge": ln_c, "discharge": ln_d}
                 
         # Swap x and y if --ro flag is set
@@ -699,8 +700,8 @@ def handle_gc_mode(args) -> int:
             ax.set_xlabel('Voltage (V)', labelpad=8.0)
             ax.set_ylabel(x_label_gc, labelpad=8.0)
         else:
-        ax.set_xlabel(x_label_gc, labelpad=8.0)
-        ax.set_ylabel('Voltage (V)', labelpad=8.0)
+            ax.set_xlabel(x_label_gc, labelpad=8.0)
+            ax.set_ylabel('Voltage (V)', labelpad=8.0)
         legend = ax.legend(title='Cycle')
         legend.get_title().set_fontsize('medium')
         fig.subplots_adjust(left=0.12, right=0.95, top=0.88, bottom=0.15)

batplot/operando_ec_interactive.py

@@ -850,6 +850,17 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "b: undo",
                 "q: quit",
             ]
+            # Conditional overwrite shortcuts under (Options)
+            last_session = getattr(fig, "_last_session_save_path", None)
+            last_style = getattr(fig, "_last_style_export_path", None)
+            last_figure = getattr(fig, "_last_figure_export_path", None)
+            if last_session:
+                col4.append("os: overwrite session")
+            if last_style:
+                col4.append("ops: overwrite style")
+                col4.append("opsg: overwrite style+geom")
+            if last_figure:
+                col4.append("oe: overwrite figure")
             # Dynamic column widths
             w1 = max(len("(Styles)"), *(len(s) for s in col1), 12)
             w2 = max(len("(Operando)"), *(len(s) for s in col2), 14)
@@ -898,6 +909,17 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "b: undo",
                 "q: quit",
             ]
+            # Conditional overwrite shortcuts under (Options)
+            last_session = getattr(fig, "_last_session_save_path", None)
+            last_style = getattr(fig, "_last_style_export_path", None)
+            last_figure = getattr(fig, "_last_figure_export_path", None)
+            if last_session:
+                col3.append("os: overwrite session")
+            if last_style:
+                col3.append("ops: overwrite style")
+                col3.append("opsg: overwrite style+geom")
+            if last_figure:
+                col3.append("oe: overwrite figure")
             w1 = max(len("(Styles)"), *(len(s) for s in col1), 12)
             w2 = max(len("(Operando)"), *(len(s) for s in col2), 14)
             w3 = max(len("(Options)"), *(len(s) for s in col3), 16)
@@ -1222,6 +1244,9 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             }
             # EC WASD state (only if ec_ax exists)
             if ec_ax is not None:
+                # For EC, check if ylabel is currently visible (not hidden by user via d5)
+                # EC uses the actual ylabel positioned on right, not a duplicate artist
+                ec_ylabel_visible = bool(ec_ax.get_ylabel())  # Empty string = hidden
                 ec_wasd = {
                     'top':    {'spine': _get_spine_visible(ec_ax, 'top'), 'ticks': ec_ax.xaxis._major_tick_kw.get('tick1On', True), 
                                'minor': bool(ec_ax.xaxis._minor_tick_kw.get('tick1On', False)), 
@@ -1234,11 +1259,11 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     'left':   {'spine': _get_spine_visible(ec_ax, 'left'), 'ticks': ec_ax.yaxis._major_tick_kw.get('tick1On', False), 
                                'minor': bool(ec_ax.yaxis._minor_tick_kw.get('tick1On', False)), 
                                'labels': ec_ax.yaxis._major_tick_kw.get('label1On', False), 
-                               'title': bool(ec_ax.get_ylabel())},
+                               'title': False},  # EC ylabel is on right, not left
                     'right':  {'spine': _get_spine_visible(ec_ax, 'right'), 'ticks': ec_ax.yaxis._major_tick_kw.get('tick2On', True), 
                                'minor': bool(ec_ax.yaxis._minor_tick_kw.get('tick2On', False)), 
                                'labels': ec_ax.yaxis._major_tick_kw.get('label2On', True), 
-                               'title': bool(ec_ax.get_ylabel())},
+                               'title': ec_ylabel_visible},  # True if ylabel is not empty
                 }
             else:
                 ec_wasd = None
@@ -1268,6 +1293,47 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     'x': getattr(ec_ax.xaxis, 'labelpad', None),
                     'y': getattr(ec_ax.yaxis, 'labelpad', None),
                 }
+            # Spine and tick widths (l command) for undo
+            op_spines_snap = {}
+            for name in ('bottom', 'top', 'left', 'right'):
+                sp = ax.spines.get(name)
+                if sp:
+                    op_spines_snap[name] = float(sp.get_linewidth())
+            op_ticks_snap = {
+                'x_major': _axis_tick_width(ax.xaxis, 'major'),
+                'x_minor': _axis_tick_width(ax.xaxis, 'minor'),
+                'y_major': _axis_tick_width(ax.yaxis, 'major'),
+                'y_minor': _axis_tick_width(ax.yaxis, 'minor'),
+            }
+            ec_spines_snap = None
+            ec_ticks_snap = None
+            ec_line_style = None
+            if ec_ax is not None:
+                ec_spines_snap = {}
+                for name in ('bottom', 'top', 'left', 'right'):
+                    sp = ec_ax.spines.get(name)
+                    if sp:
+                        ec_spines_snap[name] = float(sp.get_linewidth())
+                ec_ticks_snap = {
+                    'x_major': _axis_tick_width(ec_ax.xaxis, 'major'),
+                    'x_minor': _axis_tick_width(ec_ax.xaxis, 'minor'),
+                    'y_major': _axis_tick_width(ec_ax.yaxis, 'major'),
+                    'y_minor': _axis_tick_width(ec_ax.yaxis, 'minor'),
+                }
+                ln = getattr(ec_ax, '_ec_line', None)
+                if ln is None and ec_ax.lines:
+                    try:
+                        ln = ec_ax.lines[0]
+                    except Exception:
+                        ln = None
+                if ln is not None:
+                    try:
+                        ec_line_style = {
+                            'color': ln.get_color(),
+                            'linewidth': float(ln.get_linewidth() or 1.0),
+                        }
+                    except Exception:
+                        pass
             state_history.append({
                 'note': note,
                 'fig_size': (fig_w, fig_h),
@@ -1311,6 +1377,11 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     'right_x': float(getattr(ec_ax, '_right_ylabel_manual_offset_x_pts', 0.0) or 0.0) if ec_ax is not None else 0.0,
                     'right_y': float(getattr(ec_ax, '_right_ylabel_manual_offset_y_pts', 0.0) or 0.0) if ec_ax is not None else 0.0,
                 } if ec_ax is not None else None,
+                'op_spines': op_spines_snap,
+                'op_ticks': op_ticks_snap,
+                'ec_spines': ec_spines_snap,
+                'ec_ticks': ec_ticks_snap,
+                'ec_line_style': ec_line_style,
             })
             if len(state_history) > 40:
                 state_history.pop(0)
@@ -1548,24 +1619,31 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                                 ec_ax.tick_params(axis='x', which='minor', **{tick_key: bool(st['minor'])})
                             if 'labels' in st:
                                 ec_ax.tick_params(axis='x', which='major', **{label_key: bool(st['labels'])})
-                        elif side == 'right':  # d - only EC controls
+                        elif side == 'right':  # d - only EC controls (EC y-axis is on right by default)
                             if 'ticks' in st:
                                 ec_ax.tick_params(axis='y', which='major', left=False, right=bool(st['ticks']))
                             if 'minor' in st:
                                 ec_ax.tick_params(axis='y', which='minor', left=False, right=bool(st['minor']))
                             if 'labels' in st:
                                 ec_ax.tick_params(axis='y', which='major', labelleft=False, labelright=bool(st['labels']))
+                            print(f"[DEBUG UNDO] EC right restored: ticks={st.get('ticks')}, labels={st.get('labels')}")
                         # Title restoration
                         if side == 'top' and 'title' in st:
                             setattr(ec_ax, '_top_xlabel_on', bool(st['title']))
                         elif side == 'right' and 'title' in st:
                             # EC right title is actual ylabel, not duplicate
+                            print(f"[DEBUG UNDO] EC right title state: {st['title']}, current ylabel: '{ec_ax.get_ylabel()}'")
                             if bool(st['title']):
-                                # Keep existing ylabel or restore from ec_labels
-                                pass  # ylabel already restored above
+                                # Ylabel should be visible - restore from _stored_ylabel if it's currently empty
+                                if not ec_ax.get_ylabel() and hasattr(ec_ax, '_stored_ylabel'):
+                                    ec_ax.set_ylabel(ec_ax._stored_ylabel)
+                                    print(f"[DEBUG UNDO] Restored EC ylabel from _stored_ylabel: '{ec_ax._stored_ylabel}'")
                             else:
                                 # Hide ylabel
+                                if not hasattr(ec_ax, '_stored_ylabel'):
+                                    ec_ax._stored_ylabel = ec_ax.get_ylabel()
                                 ec_ax.set_ylabel('')
+                                print(f"[DEBUG UNDO] Hid EC ylabel, stored: '{ec_ax._stored_ylabel}'")
                 # Re-position titles using UI module functions
                 try:
                     # Build current tick state dict for UI functions
@@ -1597,11 +1675,12 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                                 ec_tick_state['b_ticks'] = st.get('ticks', True)
                                 ec_tick_state['b_labels'] = st.get('labels', True)
                             elif side == 'left':
-                                ec_tick_state['l_ticks'] = st.get('ticks', False)
-                                ec_tick_state['l_labels'] = st.get('labels', False)
+                                ec_tick_state['l_ticks'] = st.get('ticks', False)  # EC: left is off by default
+                                ec_tick_state['l_labels'] = st.get('labels', False)  # EC: left labels off
                             elif side == 'right':
-                                ec_tick_state['r_ticks'] = st.get('ticks', True)
-                                ec_tick_state['r_labels'] = st.get('labels', True)
+                                ec_tick_state['r_ticks'] = st.get('ticks', True)  # EC: right ticks ON by default
+                                ec_tick_state['r_labels'] = st.get('labels', True)  # EC: right labels ON by default
+                        print(f"[DEBUG UNDO] EC tick_state: r_ticks={ec_tick_state.get('r_ticks')}, r_labels={ec_tick_state.get('r_labels')}")
                     # Position titles
                     _ui_position_top_xlabel(ax, fig, op_tick_state)
                     _ui_position_bottom_xlabel(ax, fig, op_tick_state)
@@ -1664,10 +1743,12 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     minor = tick_lengths.get('minor')
                     if major is not None:
                         ax.tick_params(axis='both', which='major', length=major)
-                        ec_ax.tick_params(axis='both', which='major', length=major)
+                        if ec_ax is not None:
+                            ec_ax.tick_params(axis='both', which='major', length=major)
                     if minor is not None:
                         ax.tick_params(axis='both', which='minor', length=minor)
-                        ec_ax.tick_params(axis='both', which='minor', length=minor)
+                        if ec_ax is not None:
+                            ec_ax.tick_params(axis='both', which='minor', length=minor)
                     fig._tick_lengths = tick_lengths
             except Exception:
                 pass
@@ -1675,10 +1756,68 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             try:
                 tick_dir = snap.get('tick_direction', 'out')
                 ax.tick_params(axis='both', which='both', direction=tick_dir)
-                ec_ax.tick_params(axis='both', which='both', direction=tick_dir)
+                if ec_ax is not None:
+                    ec_ax.tick_params(axis='both', which='both', direction=tick_dir)
                 fig._tick_direction = tick_dir
             except Exception:
                 pass
+            # Restore spine linewidths and tick widths (l command)
+            try:
+                op_sp = snap.get('op_spines', {})
+                if op_sp:
+                    for name, lw in op_sp.items():
+                        sp = ax.spines.get(name)
+                        if sp is not None and lw is not None:
+                            sp.set_linewidth(float(lw))
+                op_tw = snap.get('op_ticks', {})
+                if op_tw:
+                    if op_tw.get('x_major') is not None:
+                        ax.tick_params(axis='x', which='major', width=op_tw['x_major'])
+                    if op_tw.get('x_minor') is not None:
+                        ax.tick_params(axis='x', which='minor', width=op_tw['x_minor'])
+                    if op_tw.get('y_major') is not None:
+                        ax.tick_params(axis='y', which='major', width=op_tw['y_major'])
+                    if op_tw.get('y_minor') is not None:
+                        ax.tick_params(axis='y', which='minor', width=op_tw['y_minor'])
+            except Exception:
+                pass
+            try:
+                if ec_ax is not None:
+                    ec_sp = snap.get('ec_spines', {})
+                    if ec_sp:
+                        for name, lw in ec_sp.items():
+                            sp = ec_ax.spines.get(name)
+                            if sp is not None and lw is not None:
+                                sp.set_linewidth(float(lw))
+                    ec_tw = snap.get('ec_ticks', {})
+                    if ec_tw:
+                        if ec_tw.get('x_major') is not None:
+                            ec_ax.tick_params(axis='x', which='major', width=ec_tw['x_major'])
+                        if ec_tw.get('x_minor') is not None:
+                            ec_ax.tick_params(axis='x', which='minor', width=ec_tw['x_minor'])
+                        if ec_tw.get('y_major') is not None:
+                            ec_ax.tick_params(axis='y', which='major', width=ec_tw['y_major'])
+                        if ec_tw.get('y_minor') is not None:
+                            ec_ax.tick_params(axis='y', which='minor', width=ec_tw['y_minor'])
+            except Exception:
+                pass
+            # Restore EC line style (el command)
+            try:
+                ec_line_style = snap.get('ec_line_style')
+                if ec_line_style and ec_ax is not None:
+                    ln = getattr(ec_ax, '_ec_line', None)
+                    if ln is None and ec_ax.lines:
+                        try:
+                            ln = ec_ax.lines[0]
+                        except Exception:
+                            ln = None
+                    if ln is not None:
+                        if ec_line_style.get('color') is not None:
+                            ln.set_color(ec_line_style['color'])
+                        if ec_line_style.get('linewidth') is not None:
+                            ln.set_linewidth(float(ec_line_style['linewidth']))
+            except Exception:
+                pass
             # Restore visibility states
             try:
                 cb_vis = snap.get('cb_visible')
@@ -2954,6 +3093,8 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                                 try: axis._stored_ylabel = axis.get_ylabel()
                                 except Exception: axis._stored_ylabel = ''
                             axis.set_ylabel("")
+                        # Set flag for right title state (used by save/export)
+                        axis._right_ylabel_on = bool(wasd_state['right']['title'])
                         # Left ylabel is disabled for EC (hide any duplicate artist)
                         # Note: EC uses the actual ylabel which is already on the right side
                     else:
@@ -2977,7 +3118,10 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     if 'left' in changed_sides:
                         _ui_position_left_ylabel(axis, fig, current_tick_state)
                     if 'right' in changed_sides:
-                        _ui_position_right_ylabel(axis, fig, current_tick_state)
+                        # EC axes use actual ylabel on right, not duplicate artist
+                        # Skip _ui_position_right_ylabel for EC to avoid creating unwanted duplicate
+                        if not is_ec:
+                            _ui_position_right_ylabel(axis, fig, current_tick_state)
                 
                 print(_colorize_inline_commands("WASD toggles: direction (w/a/s/d) x action (1..5)"))
                 print(_colorize_inline_commands("  1=spine   2=ticks   3=minor ticks   4=tick labels   5=axis title"))
@@ -4269,7 +4413,7 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             print_menu()
         elif cmd == 'i':
             # Load a .bps/.bpsg/.bpcfg style and apply
-            # Applies style properties from commands: oc, ow, ew, h, el, t, l, f, g, r
+            # Applies: oc, ow, ew, h, el, t, l, f, g, r, v; .bpsg also applies ox, oy, oz, or, et, ex, ey, er (axes_geometry + ec y_mode)
             try:
                 path = choose_style_file(file_paths, purpose="style import")
                 if not path:

batplot/session.py

@@ -564,6 +564,7 @@ def dump_session(
             'tick_state': dict(tick_state),
             'tick_widths': tick_widths,
             'tick_lengths': tick_lengths,
+            'tick_direction': getattr(fig, '_tick_direction', 'out'),
             'font': {
                 'size': plt.rcParams.get('font.size'),
                 'chain': list(plt.rcParams.get('font.sans-serif', [])),
@@ -709,20 +710,34 @@ def dump_operando_session(
         def _capture_wasd_state(axis):
             ts = getattr(axis, '_saved_tick_state', {})
             wasd = {}
+            # Check if ylabel is positioned on right (typical for EC axis)
+            ylabel_on_right = False
+            try:
+                ylabel_on_right = (axis.yaxis.get_label_position() == 'right')
+            except Exception:
+                pass
+            
             for side in ('top', 'bottom', 'left', 'right'):
                 sp = axis.spines.get(side)
                 prefix = {'top': 't', 'bottom': 'b', 'left': 'l', 'right': 'r'}[side]
-                # For 'left' side ylabel: check if it's currently visible (has text)
-                # If hidden but has stored text, the title state should be False (hidden)
+                # Title state logic
                 if side == 'left':
-                    ylabel_text = axis.get_ylabel()
-                    title_state = bool(ylabel_text)  # True only if currently visible with text
+                    # If ylabel is positioned on right (EC axis), left has no title
+                    if ylabel_on_right:
+                        title_state = False
+                    else:
+                        ylabel_text = axis.get_ylabel()
+                        title_state = bool(ylabel_text)  # True only if currently visible with text
                 elif side == 'bottom':
                     title_state = bool(axis.get_xlabel())
                 elif side == 'top':
                     title_state = bool(getattr(axis, '_top_xlabel_on', False))
                 elif side == 'right':
-                    title_state = bool(getattr(axis, '_right_ylabel_on', False))
+                    # If ylabel is positioned on right (EC axis), check if ylabel is visible (not empty)
+                    if ylabel_on_right:
+                        title_state = bool(axis.get_ylabel())  # Empty string = hidden by user
+                    else:
+                        title_state = bool(getattr(axis, '_right_ylabel_on', False))
                 else:
                     title_state = False
                 
@@ -949,6 +964,11 @@ def load_operando_session(filename: str):
     # Use standard DPI of 100 instead of saved DPI to avoid display-dependent issues
     # (Retina displays, Windows scaling, etc. can cause saved DPI to differ)
     fig = plt.figure(figsize=tuple(sess['figure']['size']), dpi=100)
+    # Seed last-session path so 'os' overwrite command is available immediately
+    try:
+        fig._last_session_save_path = os.path.abspath(filename)
+    except Exception:
+        pass
     # Disable automatic layout adjustments to preserve saved geometry
     try:
         fig.set_layout_engine('none')
@@ -1235,11 +1255,33 @@ def load_operando_session(filename: str):
                                      bottom=bool(ec_wasd.get('bottom', {}).get('ticks', True)),
                                      labeltop=bool(ec_wasd.get('top', {}).get('labels', False)),
                                      labelbottom=bool(ec_wasd.get('bottom', {}).get('labels', True)))
+                    # For EC: ticks and labels are on RIGHT by default, not left!
+                    # CRITICAL: EC y-axis defaults are: left=False, right=True (both ticks and labels)
+                    # Old sessions may have saved wrong values, so we need to sanitize them
+                    
+                    # EC left side should ALWAYS be False (EC uses right side for y-axis)
+                    left_ticks = False
+                    left_labels = False
+                    
+                    # EC right side should be True when ylabel is visible
+                    right_title = ec_wasd.get('right', {}).get('title', True)
+                    
+                    # If right title is ON, ticks/labels should also be ON
+                    if right_title:
+                        right_ticks = True
+                        right_labels = True
+                    else:
+                        # Title is hidden - respect the saved tick/label state or use False
+                        right_ticks_val = ec_wasd.get('right', {}).get('ticks')
+                        right_labels_val = ec_wasd.get('right', {}).get('labels')
+                        right_ticks = bool(right_ticks_val) if right_ticks_val is not None else False
+                        right_labels = bool(right_labels_val) if right_labels_val is not None else False
+                    
                     ec_ax.tick_params(axis='y',
-                                     left=bool(ec_wasd.get('left', {}).get('ticks', True)),
-                                     right=bool(ec_wasd.get('right', {}).get('ticks', False)),
-                                     labelleft=bool(ec_wasd.get('left', {}).get('labels', True)),
-                                     labelright=bool(ec_wasd.get('right', {}).get('labels', False)))
+                                     left=left_ticks,
+                                     right=right_ticks,
+                                     labelleft=left_labels,
+                                     labelright=right_labels)
                     # Apply minor ticks
                     if ec_wasd.get('top', {}).get('minor') or ec_wasd.get('bottom', {}).get('minor'):
                         ec_ax.xaxis.set_minor_locator(AutoMinorLocator())
@@ -1818,6 +1860,11 @@ def load_ec_session(filename: str):
     # Use standard DPI of 100 instead of saved DPI to avoid display-dependent issues
     # (Retina displays, Windows scaling, etc. can cause saved DPI to differ)
     fig = plt.figure(figsize=tuple(sess['figure']['size']), dpi=100)
+    # Seed last-session path so 'os' overwrite command is available immediately
+    try:
+        fig._last_session_save_path = os.path.abspath(filename)
+    except Exception:
+        pass
     # Preserve saved geometry by disabling auto layout
     try:
         fig.set_layout_engine('none')
@@ -2717,6 +2764,11 @@ def load_cpc_session(filename: str):
         # Use standard DPI of 100 instead of saved DPI to avoid display-dependent issues
         # (Retina displays, Windows scaling, etc. can cause saved DPI to differ)
         fig = plt.figure(figsize=tuple(sess['figure']['size']), dpi=100)
+        # Seed last-session path so 'os' overwrite command is available immediately
+        try:
+            fig._last_session_save_path = os.path.abspath(filename)
+        except Exception:
+            pass
         # Disable auto layout
         try:
             fig.set_layout_engine('none')