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

batplot/operando.py

@@ -296,6 +296,28 @@ def plot_operando_folder(folder: str, args) -> Tuple[plt.Figure, plt.Axes, Dict[
     # Result shape: (n_scans, n_x_points)
     # Example: 50 scans × 1000 points = (50, 1000) array
     Z = np.vstack(stack)  # shape (n_scans, n_x)
+    
+    # STEP 5.5: Apply first derivative if --1d or --2d flag is set
+    # This calculates dy/dx for each scan using np.gradient
+    if getattr(args, 'derivative_1d', False) or getattr(args, 'derivative_2d', False):
+        print("[operando] Applying first derivative (dy/dx) to each scan...")
+        Z_deriv = np.zeros_like(Z)
+        for i in range(Z.shape[0]):
+            row = Z[i, :]
+            # Calculate derivative using gradient (handles NaN gracefully in numpy 1.20+)
+            # Use the grid spacing for proper derivative calculation
+            dx = grid_x[1] - grid_x[0] if len(grid_x) > 1 else 1.0
+            # Replace NaN with interpolated values for gradient, then mask back
+            valid_mask = ~np.isnan(row)
+            if np.sum(valid_mask) > 1:
+                # For valid regions, calculate gradient
+                deriv = np.gradient(row, dx)
+                # Keep NaN where original was NaN
+                deriv[~valid_mask] = np.nan
+                Z_deriv[i, :] = deriv
+            else:
+                Z_deriv[i, :] = np.nan
+        Z = Z_deriv
 
     # Detect an electrochemistry .mpt file in the same folder (if any)
     # Filter out macOS resource fork files (starting with ._)

batplot/operando_ec_interactive.py

@@ -832,7 +832,8 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "ox: X range",
                 "oy: Y range",
                 "oz: intensity range",
-                "or: rename"
+                "or: rename",
+                "pk: peak search"
             ]
             col3 = [
                 "et: time range",
@@ -885,7 +886,8 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "ox: X range",
                 "oy: Y range",
                 "oz: intensity range",
-                "or: rename"
+                "or: rename",
+                "pk: peak search"
             ]
             col3 = [
                 "n: crosshair",
@@ -2285,6 +2287,234 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             except Exception as e:
                 print(f"Save failed: {e}")
             print_menu(); continue
+        if cmd == 'pk':
+            try:
+                import os
+                from .utils import choose_save_path
+                try:
+                    from scipy.signal import find_peaks
+                except ImportError:
+                    print("Error: scipy is required for peak finding. Install with: pip install scipy")
+                    print_menu(); continue
+                
+                # Get operando data
+                data_array = np.asarray(im.get_array(), dtype=float)
+                if data_array.ndim != 2 or data_array.size == 0:
+                    print("Error: No operando data available.")
+                    print_menu(); continue
+                
+                extent = im.get_extent()  # (left, right, bottom, top)
+                x0, x1, y0, y1 = extent
+                x_min, x_max = (x0, x1) if x0 <= x1 else (x1, x0)
+                y_min, y_max = (y0, y1) if y0 <= y1 else (y1, y0)
+                
+                n_scans, n_x_points = data_array.shape
+                
+                # Create x-axis array
+                x_axis = np.linspace(x_min, x_max, n_x_points)
+                
+                print("\nPeak Search Menu:")
+                print("  1: Find peaks in X range")
+                print("  e: Explanation of peak searching")
+                print("  q: Back to main menu")
+                sub = _safe_input("Choose option: ").strip().lower()
+                
+                if sub == 'e':
+                    print("\n" + "="*70)
+                    print("PEAK SEARCHING EXPLANATION")
+                    print("="*70)
+                    print("\nPeak searching identifies local maxima in diffraction patterns.")
+                    print("This is useful for tracking how peak positions change over time")
+                    print("(or scan number) in operando experiments.\n")
+                    print("HOW IT WORKS:")
+                    print("1. Select X range: Choose the region where you want to find peaks")
+                    print("2. For each scan (file):")
+                    print("   - Extract intensity profile in the selected X range")
+                    print("   - Find local maxima (peaks) using scipy.signal.find_peaks")
+                    print("   - Refine peak positions using quadratic interpolation")
+                    print("3. Export results: Peak positions vs file number saved to .txt file\n")
+                    print("PARAMETERS:")
+                    print("- Prominence: Minimum height of peak relative to surrounding baseline")
+                    print("  (Higher = fewer, stronger peaks)")
+                    print("- Distance: Minimum separation between peaks (in data points)")
+                    print("  (Larger = peaks must be further apart)")
+                    print("- Width: Minimum width of peak at half maximum")
+                    print("  (Larger = broader peaks only)\n")
+                    print("OUTPUT FORMAT:")
+                    print("The exported .txt file contains:")
+                    print("  Column 1: File number (scan index, 0-based)")
+                    print("  Column 2: Peak position (X-axis value)")
+                    print("  Column 3: Peak intensity (optional, if enabled)\n")
+                    print("="*70 + "\n")
+                    print_menu(); continue
+                
+                if sub == 'q':
+                    print_menu(); continue
+                
+                if sub == '1' or sub == '':
+                    # Get X range
+                    print(f"\nCurrent X range: {x_min:.6g} to {x_max:.6g}")
+                    print("Enter X range for peak search (min max), or press Enter to use full range:")
+                    x_range_input = _safe_input("X range: ").strip()
+                    
+                    if x_range_input:
+                        try:
+                            parts = x_range_input.split()
+                            if len(parts) >= 2:
+                                x_range_min = float(parts[0])
+                                x_range_max = float(parts[1])
+                            else:
+                                print("Invalid format. Use: min max")
+                                print_menu(); continue
+                        except ValueError:
+                            print("Invalid number format.")
+                            print_menu(); continue
+                    else:
+                        x_range_min = x_min
+                        x_range_max = x_max
+                    
+                    # Clamp to valid range
+                    x_range_min = max(x_min, min(x_max, x_range_min))
+                    x_range_max = max(x_min, min(x_max, x_range_max))
+                    if x_range_min >= x_range_max:
+                        print("Invalid range: min must be < max")
+                        print_menu(); continue
+                    
+                    # Find column indices for X range
+                    col_min = int(np.argmin(np.abs(x_axis - x_range_min)))
+                    col_max = int(np.argmin(np.abs(x_axis - x_range_max)))
+                    if col_min > col_max:
+                        col_min, col_max = col_max, col_min
+                    col_max = min(col_max + 1, n_x_points)  # Include endpoint
+                    
+                    # Get parameters for peak finding
+                    print("\nPeak finding parameters:")
+                    prominence_input = _safe_input("Prominence (relative to max, default 0.1): ").strip()
+                    prominence = float(prominence_input) if prominence_input else 0.1
+                    
+                    distance_input = _safe_input("Minimum distance between peaks (data points, default 5): ").strip()
+                    distance = int(distance_input) if distance_input else 5
+                    
+                    width_input = _safe_input("Minimum peak width (data points, default 1, 0=disabled): ").strip()
+                    width = int(width_input) if width_input else 1
+                    
+                    include_intensity = _safe_input("Include peak intensity in output? (y/n, default n): ").strip().lower() == 'y'
+                    
+                    # Find peaks for each scan
+                    print(f"\nFinding peaks in X range [{x_range_min:.6g}, {x_range_max:.6g}]...")
+                    results = []
+                    
+                    for scan_idx in range(n_scans):
+                        # Extract intensity profile for this scan in X range
+                        intensity_profile = data_array[scan_idx, col_min:col_max]
+                        x_profile = x_axis[col_min:col_max]
+                        
+                        if len(intensity_profile) < 3:
+                            continue
+                        
+                        # Find peaks
+                        try:
+                            # Calculate prominence threshold
+                            max_intensity = np.max(intensity_profile)
+                            min_intensity = np.min(intensity_profile)
+                            prominence_abs = (max_intensity - min_intensity) * prominence
+                            
+                            peak_kwargs = {
+                                'prominence': prominence_abs if prominence_abs > 0 else None,
+                                'distance': max(1, distance),
+                            }
+                            if width > 0:
+                                peak_kwargs['width'] = width
+                            
+                            # Remove None values
+                            peak_kwargs = {k: v for k, v in peak_kwargs.items() if v is not None}
+                            
+                            peak_indices, peak_properties = find_peaks(intensity_profile, **peak_kwargs)
+                            
+                            # Refine peak positions using quadratic interpolation
+                            for peak_idx in peak_indices:
+                                if peak_idx == 0 or peak_idx == len(intensity_profile) - 1:
+                                    peak_x = x_profile[peak_idx]
+                                    peak_intensity = intensity_profile[peak_idx]
+                                else:
+                                    # Quadratic interpolation for sub-pixel accuracy
+                                    y1 = intensity_profile[peak_idx - 1]
+                                    y2 = intensity_profile[peak_idx]
+                                    y3 = intensity_profile[peak_idx + 1]
+                                    x1 = x_profile[peak_idx - 1]
+                                    x2 = x_profile[peak_idx]
+                                    x3 = x_profile[peak_idx + 1]
+                                    
+                                    denom = (y1 - 2*y2 + y3)
+                                    if abs(denom) > 1e-12:
+                                        dx = 0.5 * (y1 - y3) / denom
+                                        if -0.6 < dx < 0.6:
+                                            peak_x = x2 + dx * (x3 - x1) / 2.0
+                                            peak_intensity = y2 + 0.5 * dx * (y3 - y1)
+                                        else:
+                                            peak_x = x2
+                                            peak_intensity = y2
+                                    else:
+                                        peak_x = x2
+                                        peak_intensity = y2
+                                
+                                if include_intensity:
+                                    results.append((scan_idx, peak_x, peak_intensity))
+                                else:
+                                    results.append((scan_idx, peak_x))
+                        except Exception as e:
+                            # Skip this scan if peak finding fails
+                            continue
+                    
+                    if not results:
+                        print("No peaks found in the selected X range.")
+                        print_menu(); continue
+                    
+                    # Save results
+                    folder = choose_save_path(file_paths, purpose="peak search export")
+                    if not folder:
+                        print_menu(); continue
+                    
+                    print(f"\nChosen path: {folder}")
+                    fname = _safe_input("Export filename (default: peaks.txt): ").strip()
+                    if not fname:
+                        fname = "peaks.txt"
+                    if not fname.endswith('.txt'):
+                        fname += '.txt'
+                    
+                    target = fname if os.path.isabs(fname) else os.path.join(folder, fname)
+                    if os.path.exists(target):
+                        yn = _safe_input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
+                        if yn != 'y':
+                            print_menu(); continue
+                    
+                    # Write results
+                    try:
+                        with open(target, 'w') as f:
+                            if include_intensity:
+                                f.write("# File number\tPeak position\tPeak intensity\n")
+                                for scan_idx, peak_x, peak_intensity in results:
+                                    f.write(f"{scan_idx}\t{peak_x:.6f}\t{peak_intensity:.6f}\n")
+                            else:
+                                f.write("# File number\tPeak position\n")
+                                for result in results:
+                                    if len(result) == 2:
+                                        scan_idx, peak_x = result
+                                        f.write(f"{scan_idx}\t{peak_x:.6f}\n")
+                                    else:
+                                        scan_idx, peak_x, _ = result
+                                        f.write(f"{scan_idx}\t{peak_x:.6f}\n")
+                        print(f"Peak positions exported to {target}")
+                        print(f"Found {len(results)} peaks across {len(set(r[0] for r in results))} scans")
+                    except Exception as e:
+                        print(f"Error saving file: {e}")
+                else:
+                    print("Invalid option.")
+            except Exception as e:
+                print(f"Error in peak search: {e}")
+                import traceback
+                traceback.print_exc()
+            print_menu(); continue
         if cmd == 'h':
             # Always read fresh value from attribute to avoid stale cached value
             ax_h_in = getattr(ax, '_fixed_ax_h_in', ax_h_in)

batplot/session.py

@@ -500,6 +500,30 @@ def dump_session(
             'orig_y': [np.array(a) for a in orig_y],
             'offsets': list(offsets_list),
             'labels': list(labels),
+            # Processed data (for smooth/reduce operations)
+            'original_x_data_list': ([np.array(a) for a in getattr(fig, '_original_x_data_list', [])] 
+                                     if hasattr(fig, '_original_x_data_list') else None),
+            'original_y_data_list': ([np.array(a) for a in getattr(fig, '_original_y_data_list', [])] 
+                                     if hasattr(fig, '_original_y_data_list') else None),
+            'full_processed_x_data_list': ([np.array(a) for a in getattr(fig, '_full_processed_x_data_list', [])] 
+                                            if hasattr(fig, '_full_processed_x_data_list') else None),
+            'full_processed_y_data_list': ([np.array(a) for a in getattr(fig, '_full_processed_y_data_list', [])] 
+                                            if hasattr(fig, '_full_processed_y_data_list') else None),
+            'smooth_settings': (dict(getattr(fig, '_smooth_settings', {})) 
+                               if hasattr(fig, '_smooth_settings') else None),
+            'last_smooth_settings': (dict(getattr(fig, '_last_smooth_settings', {})) 
+                                    if hasattr(fig, '_last_smooth_settings') else None),
+            # Derivative data (for derivative operations)
+            'pre_derivative_x_data_list': ([np.array(a) for a in getattr(fig, '_pre_derivative_x_data_list', [])] 
+                                           if hasattr(fig, '_pre_derivative_x_data_list') else None),
+            'pre_derivative_y_data_list': ([np.array(a) for a in getattr(fig, '_pre_derivative_y_data_list', [])] 
+                                           if hasattr(fig, '_pre_derivative_y_data_list') else None),
+            'pre_derivative_ylabel': (str(getattr(fig, '_pre_derivative_ylabel', '')) 
+                                      if hasattr(fig, '_pre_derivative_ylabel') else None),
+            'derivative_order': (int(getattr(fig, '_derivative_order', 0)) 
+                                if hasattr(fig, '_derivative_order') else None),
+            'derivative_reversed': (bool(getattr(fig, '_derivative_reversed', False)) 
+                                   if hasattr(fig, '_derivative_reversed') else None),
             'line_styles': [
                 {
                     'color': ln.get_color(),

batplot/style.py

@@ -451,7 +451,19 @@ def print_style_info(
     except Exception:
         pass
 
-    # Omit CIF/HKL details from compact style print
+    # CIF hkl label visibility
+    if show_cif_hkl is not None:
+        print(f"CIF hkl labels: {'shown' if show_cif_hkl else 'hidden'}")
+    elif cif_tick_series:
+        # Try to read from __main__ module if not provided
+        try:
+            import sys
+            _bp_module = sys.modules.get('__main__')
+            if _bp_module is not None and hasattr(_bp_module, 'show_cif_hkl'):
+                hkl_state = bool(getattr(_bp_module, 'show_cif_hkl', False))
+                print(f"CIF hkl labels: {'shown' if hkl_state else 'hidden'}")
+        except Exception:
+            pass
 
     # Omit non-style global flags (mode/raw/autoscale/delta)
 
@@ -670,6 +682,14 @@ def export_style_config(
         # Save CIF title visibility
         if show_cif_titles is not None:
             cfg["show_cif_titles"] = bool(show_cif_titles)
+        # Save CIF hkl label visibility (read from __main__ module if available)
+        try:
+            import sys
+            _bp_module = sys.modules.get('__main__')
+            if _bp_module is not None and hasattr(_bp_module, 'show_cif_hkl'):
+                cfg["show_cif_hkl"] = bool(getattr(_bp_module, 'show_cif_hkl', False))
+        except Exception:
+            pass
         if cif_tick_series:
             cfg["cif_ticks"] = [
                 {"index": i, "color": color}
@@ -692,6 +712,20 @@ def export_style_config(
             if serialized_palettes:
                 cfg['curve_palettes'] = serialized_palettes
         
+        # Store smooth settings (metadata only, not full arrays)
+        if hasattr(fig, '_smooth_settings'):
+            cfg['smooth_settings'] = dict(fig._smooth_settings)
+        if hasattr(fig, '_last_smooth_settings'):
+            cfg['last_smooth_settings'] = dict(fig._last_smooth_settings)
+        # Store derivative order (metadata only)
+        if hasattr(fig, '_derivative_order'):
+            cfg['derivative_order'] = int(fig._derivative_order)
+        if hasattr(fig, '_derivative_reversed'):
+            cfg['derivative_reversed'] = bool(fig._derivative_reversed)
+        # Note: We don't store original_x_data_list/original_y_data_list or pre_derivative data in style files
+        # as style files are for styling only, and the data would be specific
+        # to the dataset. Session files (pickle) store this data instead.
+        
         # If overwrite_path is provided, determine export type from existing file
         if overwrite_path:
             try:
@@ -1230,8 +1264,61 @@ def apply_style_config(
                     setattr(_bp_module, 'show_cif_titles', bool(cfg["show_cif_titles"]))
             except Exception:
                 pass
+        # Restore CIF hkl label visibility
+        if "show_cif_hkl" in cfg:
+            try:
+                _bp_module = sys.modules.get('__main__')
+                if _bp_module is not None:
+                    setattr(_bp_module, 'show_cif_hkl', bool(cfg["show_cif_hkl"]))
+                # Also update _bp object if available
+                if cif_tick_series is not None:
+                    # Try to update via interactive menu's _bp object
+                    try:
+                        import sys
+                        _bp_obj = getattr(sys.modules.get('__main__'), '_bp', None)
+                        if _bp_obj is not None:
+                            setattr(_bp_obj, 'show_cif_hkl', bool(cfg["show_cif_hkl"]))
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+        # Restore smooth settings (metadata only, not full arrays)
+        if "smooth_settings" in cfg:
+            try:
+                fig._smooth_settings = dict(cfg["smooth_settings"])
+            except Exception:
+                pass
+        elif hasattr(fig, '_smooth_settings'):
+            delattr(fig, '_smooth_settings')
+        if "last_smooth_settings" in cfg:
+            try:
+                fig._last_smooth_settings = dict(cfg["last_smooth_settings"])
+            except Exception:
+                pass
+        elif hasattr(fig, '_last_smooth_settings'):
+            delattr(fig, '_last_smooth_settings')
+        # Restore derivative order (metadata only)
+        if "derivative_order" in cfg:
+            try:
+                order = int(cfg["derivative_order"])
+                fig._derivative_order = order
+                is_reversed = cfg.get("derivative_reversed", False)
+                if "derivative_reversed" in cfg:
+                    fig._derivative_reversed = bool(cfg["derivative_reversed"])
+                # Update y-axis label based on derivative order
+                from .interactive import _update_ylabel_for_derivative
+                current_ylabel = ax.get_ylabel() or ""
+                new_ylabel = _update_ylabel_for_derivative(order, current_ylabel, is_reversed=is_reversed)
+                ax.set_ylabel(new_ylabel)
+            except Exception:
+                pass
+        elif hasattr(fig, '_derivative_order'):
+            delattr(fig, '_derivative_order')
+        # Note: We don't restore original_x_data_list/original_y_data_list or pre_derivative data from style files
+        # as style files are for styling only, and the data would be specific
+        # to the dataset. Session files (pickle) store this data instead.
         # Redraw CIF ticks after applying changes
-        if (cif_cfg and cif_tick_series is not None) or "show_cif_titles" in cfg:
+        if (cif_cfg and cif_tick_series is not None) or "show_cif_titles" in cfg or "show_cif_hkl" in cfg:
             if hasattr(ax, "_cif_draw_func"):
                 try:
                     ax._cif_draw_func()

{batplot-1.8.4.dist-info → batplot-1.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batplot
-Version: 1.8.4
+Version: 1.8.5
 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.4.dist-info → batplot-1.8.5.dist-info}/RECORD

@@ -1,28 +1,28 @@
-batplot/__init__.py,sha256=A2c5RdJQEC4-Snfk1leoeq38dCyGoAxBuEvXo3Kb50A,118
-batplot/args.py,sha256=mrDjMURp_OQnXrAwl9WnE_FW4HJu940O7NmL9QWQnD4,35189
-batplot/batch.py,sha256=P2HNBYqrSzDr2fruYz8BFKwNFX6vdJpHDZpaG_hmEc8,55253
-batplot/batplot.py,sha256=IDnc-aGIMo1oMfXsQjU_koKqq2E9xXNn1Bm92xsmeYE,177109
+batplot/__init__.py,sha256=6mfbpfSzbSfjCLrvmBzBMKmDyiFSBUJlcB8Qqv6o26s,118
+batplot/args.py,sha256=DGTe2PKmJnI8Iq12QgO76V8lZvWhMOqY14gsyE5SgEs,37001
+batplot/batch.py,sha256=hqLNvd88OLd0PLo_ot6JjC3FM6wwxCJ1jO2J63f9Zyg,55899
+batplot/batplot.py,sha256=-mAf1aW7bniyfQ5DCorqyOr-OcRtUgRtq6TZHKk5xCU,184599
 batplot/cif.py,sha256=JfHwNf3SHrcpALc_F5NjJmQ3lg71MBRSaIUJjGYPTx8,30120
 batplot/cli.py,sha256=2-7NtxBlyOUfzHVwP7vZK7OZlyKyPVy-3daKN-MPWyU,6657
 batplot/color_utils.py,sha256=7InQLVo1XTg7sgAbltM2KeDSFJgr787YEaV9vJbIoWY,20460
 batplot/config.py,sha256=6nGY7fKN4T5KZUGQS2ArUBgEkLAL0j37XwG5SCVQgKA,6420
-batplot/converters.py,sha256=rR2WMPM0nR5E3eZI3gWbaJf_AfbdQx3urVSbJmZXNzo,8237
-batplot/cpc_interactive.py,sha256=qadWV2PaQMsqM16mSp5r1-WP7di0JCnzNI4RJy27alo,239616
-batplot/electrochem_interactive.py,sha256=8mFr5vtWb_ZDiJmZWXjkARq21D2GflT8-J2xvCGvDIc,222769
-batplot/interactive.py,sha256=5u2ulhTzRr7fA-INc5hfcz7xaHObnnigiXjrgdtE7XE,206728
+batplot/converters.py,sha256=c4qhgN9zHUiBZhXVAdf0zGtPPoktD3JjMLkhjjYEwlk,9787
+batplot/cpc_interactive.py,sha256=-9etN342VqLbY9pLP7cyBcSzgVHuWpDwEZHkXzShl7E,240683
+batplot/electrochem_interactive.py,sha256=a3ocYQEfi0FsiMq9B4_0GY97td00e8uyzlHc3Sr6EKE,225211
+batplot/interactive.py,sha256=b-0xeza_Rs4S59ve-pyWVq_-FvTpqDIy1tu4M3tT3Eg,300447
 batplot/manual.py,sha256=pbRI6G4Pm12pOW8LrOLWWu7IEOtqWN3tRHtgge50LlA,11556
 batplot/modes.py,sha256=qE2OsOQQKhwOWene5zxJeuuewTrZxubtahQuz5je7ok,37252
-batplot/operando.py,sha256=p2Ug1mFUQxaU702cTBGgJKb3_v1C2p3LLUwfXaVBpPY,28311
-batplot/operando_ec_interactive.py,sha256=8GQ47-I8SLTS88sFEk8m3vDxFEjSfD3hao62Qke7SxA,305137
+batplot/operando.py,sha256=h09xu1BsdR68YlzhWeUSypYX83DzjJABIQQS2noQzPI,29400
+batplot/operando_ec_interactive.py,sha256=YExiuKn-qQksW3YFYCTpvumuCit4cc4YiiaSRWGa0og,317833
 batplot/plotting.py,sha256=hG2_EdDhF1Qpn1XfZKdCQ5-w_m9gUYFbr804UQ5QjsU,10841
 batplot/readers.py,sha256=kAI0AvYrdfGRZkvADJ4riN96IWtrH24aAoZpBtONTbw,112960
-batplot/session.py,sha256=sYhY3WH-Kks5SMO91kfGDkSs32SX_iFS62ZkUm3jwzY,142722
-batplot/style.py,sha256=jXtFaJR1aa6vIHupmDNqY2NY5Rgtw49UxF7cS4y8fCA,63375
+batplot/session.py,sha256=sgcJyCj00lOhmIRdDxGSqu2vEpOm7WSFZzLXxukYNL0,144936
+batplot/style.py,sha256=3XnWlU9aTb1b-aiq5BQOuAREE5nOEYZ0b75v_LS0xDM,67790
 batplot/ui.py,sha256=ifpbK74juUzLMCt-sJGVaWtpDb1NMRJzs2YyiwwafzY,35302
 batplot/utils.py,sha256=LY2-Axr3DsQMTxuXe48vSjrLJKEnkzkZjdSFdQizbpg,37599
 batplot/version_check.py,sha256=--U_74DKgHbGtVdBsg9DfUJ10S5-OMXT-rzaYjK0JBc,9997
-batplot/data/USER_MANUAL.md,sha256=VYPvNZt3Fy8Z4Izr2FnQBw9vEaFTPkybhHDnF-OuKws,17694
-batplot-1.8.4.dist-info/licenses/LICENSE,sha256=2PAnHeCiTfgI7aKZLWr0G56HI9fGKQ0CEbQ02H-yExQ,1065
+batplot/data/USER_MANUAL.md,sha256=w6pmDXoLINFkCWWh3zay7uNIxUaDxSOrocnPIZwu2uA,19542
+batplot-1.8.5.dist-info/licenses/LICENSE,sha256=2PAnHeCiTfgI7aKZLWr0G56HI9fGKQ0CEbQ02H-yExQ,1065
 batplot_backup_20251121_223043/__init__.py,sha256=3s2DUQuTbWs65hoN9cQQ8IiJbaFJY8fNxiCpwRBYoOA,118
 batplot_backup_20251121_223043/args.py,sha256=OH-h84QhN-IhMS8sPAsSEqccHD3wpeMgmXa_fqv5xtg,21215
 batplot_backup_20251121_223043/batch.py,sha256=oI7PONJyciHDOqNPq-8fnOQMyn9CpAdVznKaEdsy0ig,48650
@@ -68,8 +68,8 @@ batplot_backup_20251221_101150/style.py,sha256=ig1ozX4dhEsXf5JKaPZOvgVS3CWx-BTFS
 batplot_backup_20251221_101150/ui.py,sha256=ifpbK74juUzLMCt-sJGVaWtpDb1NMRJzs2YyiwwafzY,35302
 batplot_backup_20251221_101150/utils.py,sha256=LY2-Axr3DsQMTxuXe48vSjrLJKEnkzkZjdSFdQizbpg,37599
 batplot_backup_20251221_101150/version_check.py,sha256=ztTHwqgWd8OlS9PLLY5A_TabWxBASDA_-5yyN15PZC8,9996
-batplot-1.8.4.dist-info/METADATA,sha256=da51wuDhz7bqCTInJ_tjZzZy2wC6ujSfsrgYIi-GYgI,7175
-batplot-1.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-batplot-1.8.4.dist-info/entry_points.txt,sha256=73GgH3Zs-qGIvgiyQLgGsSW-ryOwPPKHveOW6TDIR5Q,82
-batplot-1.8.4.dist-info/top_level.txt,sha256=Z5Q4sAiT_FDqZqhlLsYn9avRTuFAEEf3AVfkswxOb18,70
-batplot-1.8.4.dist-info/RECORD,,
+batplot-1.8.5.dist-info/METADATA,sha256=WTflN9nVzAXg4xPnjpjfJeRNhuyUaXaJKBLyjhjVxko,7175
+batplot-1.8.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+batplot-1.8.5.dist-info/entry_points.txt,sha256=73GgH3Zs-qGIvgiyQLgGsSW-ryOwPPKHveOW6TDIR5Q,82
+batplot-1.8.5.dist-info/top_level.txt,sha256=Z5Q4sAiT_FDqZqhlLsYn9avRTuFAEEf3AVfkswxOb18,70
+batplot-1.8.5.dist-info/RECORD,,

{batplot-1.8.4.dist-info → batplot-1.8.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any