setiastrosuitepro 1.6.1.post1__py3-none-any.whl → 1.6.4__py3-none-any.whl

setiastro/saspro/star_spikes.py

@@ -1,7 +1,7 @@
 # pro/tools/star_spikes.py
 from __future__ import annotations
 import numpy as np
-
+import math
 from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QSplitter, QSizePolicy, QWidget, QApplication,
                              QFormLayout, QGroupBox, QDoubleSpinBox, QSpinBox, 
@@ -50,6 +50,9 @@ class StarSpikesDialogPro(QDialog):
                  spinner_path: str | None = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Diffraction Spikes"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.docman = doc_manager
         self.doc = initial_doc or (self.docman.get_active_document() if self.docman else None)
         self.jwstpupil_path = jwstpupil_path
@@ -381,6 +384,13 @@ class StarSpikesDialogPro(QDialog):
         shrink_max = self.advanced["shrink_max"]
         color_boost = self.color_boost.value()
 
+        # Try OpenCV for faster zoom/blur
+        try:
+            import cv2
+            _HAS_CV2 = True
+        except ImportError:
+            _HAS_CV2 = False
+
         from concurrent.futures import ThreadPoolExecutor, as_completed
         def star_runner(x, y, flux, a, b):
             brightness = np.clip(np.log1p(flux)/8.0, 0.1, 3.0)
@@ -388,39 +398,79 @@ class StarSpikesDialogPro(QDialog):
             tile_size  = min(tile_size, 768)
             tile_size += tile_size % 2
             pad = tile_size // 2
-            if not (pad <= x < W - pad and pad <= y < H - pad):
+
+            # Guard against fully out-of-bounds, but allow partial overlaps
+            if not (0 <= x < W and 0 <= y < H):
                 return None
 
+            # Measure star color
             r_ratio, g_ratio, b_ratio = self._measure_star_color(img, x, y, sampling_radius=3)
+            
+            # Extract PSF tiles
             tile_r = self._extract_center_tile(psf_r, tile_size) * brightness * r_ratio * color_boost
             tile_g = self._extract_center_tile(psf_g, tile_size) * brightness * g_ratio * color_boost
             tile_b = self._extract_center_tile(psf_b, tile_size) * brightness * b_ratio * color_boost
 
+            # Boost/Shrink
             b_scale, s_factor = self._boost_shrink_from_flux(flux, self.flux_min.value(), flux_max,
                                                              bscale_min, bscale_max, shrink_min, shrink_max)
-            final_r = self._shrink_and_boost(tile_r, b_scale, s_factor)
-            final_g = self._shrink_and_boost(tile_g, b_scale, s_factor)
-            final_b = self._shrink_and_boost(tile_b, b_scale, s_factor)
-
-            new_size = final_r.shape[0]
-            pad_new  = new_size // 2
-            y0, y1   = y - pad_new, y - pad_new + new_size
-            x0, x1   = x - pad_new, x - pad_new + new_size
-            if (y0 < 0 or y1 > H or x0 < 0 or x1 > W):
-                return None
 
-            part = np.zeros((H, W, 3), dtype=np.float32)
-            part[y0:y1, x0:x1, 0] = final_r
-            part[y0:y1, x0:x1, 1] = final_g
-            part[y0:y1, x0:x1, 2] = final_b
-            return part
+            # --- Fast Resize (Zoom) ---
+            def _fast_zoom(arr, z):
+                if z == 1.0: return arr
+                if _HAS_CV2:
+                     h, w = arr.shape
+                     nw, nh = int(round(w * z)), int(round(h * z))
+                     if nw <= 0 or nh <= 0: return np.zeros((2,2), dtype=np.float32)
+                     return cv2.resize(arr, (nw, nh), interpolation=cv2.INTER_LINEAR)
+                else:
+                    return ndi.zoom(arr, z, order=1)
+
+            final_r = np.clip(_fast_zoom(tile_r * b_scale, 1.0/s_factor), 0.0, 1.0)
+            final_g = np.clip(_fast_zoom(tile_g * b_scale, 1.0/s_factor), 0.0, 1.0)
+            final_b = np.clip(_fast_zoom(tile_b * b_scale, 1.0/s_factor), 0.0, 1.0)
+
+            # --- Return Patch Data (y, x, patch) ---
+            new_h, new_w = final_r.shape
+            
+            # Coords of the *patch top-left* relative to the image
+            # The star is at (x,y), and the patch center is approx (new_w//2, new_h//2)
+            # We want to center the patch on the star.
+            py0 = y - (new_h // 2)
+            px0 = x - (new_w // 2)
+            
+            # Combine channels
+            patch = np.dstack((final_r, final_g, final_b)).astype(np.float32)
+            return (int(py0), int(px0), patch)
 
         with ThreadPoolExecutor() as ex:
             futs = [ex.submit(star_runner, *s) for s in stars]
             for f in as_completed(futs):
-                part = f.result()
-                if part is not None:
-                    canvas += part
+                res = f.result()
+                if res is None:
+                    continue
+                
+                py0, px0, patch = res
+                ph, pw, _ = patch.shape
+                
+                # Calculate intersection with canvas
+                y_start = max(0, py0)
+                y_end   = min(H, py0 + ph)
+                x_start = max(0, px0)
+                x_end   = min(W, px0 + pw)
+                
+                # If no overlap, skip
+                if y_start >= y_end or x_start >= x_end:
+                    continue
+
+                # Offsets into the patch
+                patch_y_start = y_start - py0
+                patch_y_end   = patch_y_start + (y_end - y_start)
+                patch_x_start = x_start - px0
+                patch_x_end   = patch_x_start + (x_end - x_start)
+
+                # Add to canvas
+                canvas[y_start:y_end, x_start:x_end] += patch[patch_y_start:patch_y_end, patch_x_start:patch_x_end]
 
         self.status.setText("Compositing…")
         QApplication.processEvents()
@@ -543,14 +593,56 @@ class StarSpikesDialogPro(QDialog):
         return img
 
     def _simulate_psf(self, pupil, wavelength_scale=1.0, blur_sigma=1.0):
-        sp = gaussian_filter(pupil, sigma=0.1 * wavelength_scale)
+        # Try to use OpenCV for speed
+        if getattr(self, "_cv2_checked", False):
+            has_cv2 = True
+            import cv2
+        else:
+            try:
+                import cv2
+                has_cv2 = True
+            except ImportError:
+                has_cv2 = False
+            self._cv2_checked = has_cv2
+
+        if has_cv2:
+            # Gaussian blur on pupil
+            # kernel size usually ~6*sigma, must be odd
+            k_pupil = int(math.ceil(6 * (0.1 * wavelength_scale))) | 1
+            sp = cv2.GaussianBlur(pupil, (k_pupil, k_pupil), 0.1 * wavelength_scale)
+        else:
+            sp = gaussian_filter(pupil, sigma=0.1 * wavelength_scale)
+        
         fft = np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(sp)))
         intensity = np.abs(fft)**2
         intensity /= (intensity.max() + 1e-8)
-        blurred = gaussian_filter(intensity, sigma=blur_sigma)
+        
+        if has_cv2 and blur_sigma > 0:
+            k_blur = int(math.ceil(6 * blur_sigma)) | 1
+            blurred = cv2.GaussianBlur(intensity, (k_blur, k_blur), blur_sigma)
+        else:
+            blurred = gaussian_filter(intensity, sigma=blur_sigma)
+            
         psf = blurred / max(blurred.max(), 1e-8)
+        
         if wavelength_scale != 1.0:
-            psf = ndi.zoom(psf, zoom=wavelength_scale, order=1)
+            if has_cv2:
+                h, w = psf.shape
+                # Zoom uses size, NOT scale factor in resize(..., dsize=(w,h))
+                # wavelength_scale > 1 => zoom in => crop middle? or simply scale?
+                # The original used ndi.zoom(psf, zoom=wavelength_scale).
+                # New size:
+                nw, nh = int(round(w * wavelength_scale)), int(round(h * wavelength_scale))
+                if nw > 0 and nh > 0:
+                    scaled = cv2.resize(psf, (nw, nh), interpolation=cv2.INTER_LINEAR)
+                    # We might need to crop back to original size or pad?
+                    # ndi.zoom changes the array size.
+                    # The simulator seems to assume we handle whatever size comes out?
+                    # Let's check _extract_center_tile usage.
+                    psf = scaled
+            else:
+                 psf = ndi.zoom(psf, zoom=wavelength_scale, order=1)
+            
             psf /= psf.max() + 1e-12
         return psf
 
@@ -591,15 +683,7 @@ class StarSpikesDialogPro(QDialog):
                 stars.append((int(obj['x']), int(obj['y']), float(flux), float(a), float(b)))
         return stars
 
-    @staticmethod
-    def _shrink_and_boost(tile, brightness_scale=2.0, shrink_factor=1.5):
-        tile = np.clip(tile * float(brightness_scale), 0.0, 1.0)
-        in_sz = tile.shape[0]
-        out_sz = int(in_sz // float(shrink_factor))
-        out_sz += out_sz % 2
-        if out_sz <= 0: out_sz = 2
-        z = out_sz / float(in_sz)
-        return np.clip(ndi.zoom(tile, z, order=1), 0.0, 1.0)
+    # _shrink_and_boost removed (replaced by inline _fast_zoom for performance)
 
     @staticmethod
     def _boost_shrink_from_flux(flux, flux_min, flux_max, bmin, bmax, smin, smax):

setiastro/saspro/star_stretch.py

@@ -127,8 +127,16 @@ class StarStretchDialog(QDialog):
     def __init__(self, parent, document):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Star Stretch"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
+        self._main = parent
         self.doc = document
         self._preview: np.ndarray | None = None
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
         self._pix: QPixmap | None = None
         self._zoom = 0.25
         self._panning = False
@@ -225,6 +233,15 @@ class StarStretchDialog(QDialog):
         # initialize preview with current doc image
         self._update_preview_pix(self.doc.image)
 
+    # --- active document change ---
+    def _on_active_doc_changed(self, doc):
+        """Called when user clicks a different image window."""
+        if doc is None or getattr(doc, "image", None) is None:
+            return
+        self.doc = doc
+        self._preview = None
+        self._update_preview_pix(self.doc.image)
+
     # --- UI change handlers ---
     def _on_stretch_changed(self, v: int):
         self.lbl_st.setText(f"Stretch Amount: {v/100.0:.2f}")
@@ -325,7 +342,27 @@ class StarStretchDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Apply failed", str(e))
             return
-        self.accept()
+        
+        # Dialog stays open so user can apply to other images
+        # Refresh document reference for next operation
+        self._refresh_document_from_active()
+
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self._find_main_window()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Reset preview for new document
+                    self._preview = None
+                    self._compute_and_show_preview()
+        except Exception:
+            pass
 
 
     # --- preview rendering ---

setiastro/saspro/stat_stretch.py

@@ -25,13 +25,18 @@ class StatisticalStretchDialog(QDialog):
         # --- IMPORTANT: avoid “attached modal” behavior on some Linux WMs ---
         # Make this a proper top-level window (tool-style) rather than an attached sheet.
         self.setWindowFlag(Qt.WindowType.Window, True)
-        # Block the app if you want, but don't use WindowModal
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         # Don’t let the generic modal flag override the explicit modality
         self.setModal(False)
 
+        self._main = parent
         self.doc = document
         self._last_preview = None
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
         self._panning = False
         self._pan_last = None  # QPoint
         self._preview_scale = 1.0       # NEW: zoom factor for preview
@@ -329,6 +334,14 @@ class StatisticalStretchDialog(QDialog):
         self._preview_qimg = qimg
         self._apply_current_zoom() 
 
+    # ----- active document change -----
+    def _on_active_doc_changed(self, doc):
+        """Called when user clicks a different image window."""
+        if doc is None or getattr(doc, "image", None) is None:
+            return
+        self.doc = doc
+        self._populate_initial_preview()
+
     # ----- slots -----
     def _populate_initial_preview(self):
         # show the current (unstretched) image as baseline
@@ -433,12 +446,31 @@ class StatisticalStretchDialog(QDialog):
                 # optional debug
                 print("Statistical Stretch: replay recording suppressed for this apply()")
 
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Update the document reference to reflect the now-active document
+            self._refresh_document_from_active()
 
 
         except Exception as e:
             QMessageBox.critical(self, "Apply failed", str(e))
 
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Reset preview state for new document
+                    self._last_preview = None
+                    self._preview_qimg = None
+        except Exception:
+            pass
+
 
     def _update_preview_scaled(self):
         if self._preview_qimg is None:

setiastro/saspro/status_log_dock.py

@@ -9,7 +9,7 @@ class StatusLogDock(QDockWidget):
     MAX_BLOCKS = 2000
 
     def __init__(self, parent=None):
-        super().__init__("Stacking Log", parent)
+        super().__init__(self.tr("Stacking Log"), parent)
         self.setObjectName("StackingLogDock")
         self.setAllowedAreas(
             Qt.DockWidgetArea.BottomDockWidgetArea

setiastro/saspro/subwindow.py

@@ -371,7 +371,8 @@ class ImageSubWindow(QWidget):
         # pixel readout live-probe state
         self._space_down = False
         self._readout_dragging = False
-        self._last_readout = None
+        # Pinch gesture state (macOS trackpad)
+        self._gesture_zoom_start = None
         self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
 
         # Title (doc/view) sync
@@ -484,6 +485,7 @@ class ImageSubWindow(QWidget):
 
         self.scroll = QScrollArea(full_host)
         self.scroll.setWidgetResizable(False)
+        self.scroll.setAlignment(Qt.AlignmentFlag.AlignCenter)        
         self.label = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
         self.scroll.setWidget(self.label)
         self.scroll.viewport().setMouseTracking(True)
@@ -2526,6 +2528,43 @@ class ImageSubWindow(QWidget):
             p = p.parent()
         return p
 
+    def event(self, e):
+        """Override event() to handle native macOS gestures (pinch zoom)."""
+        # Handle native gestures (macOS trackpad pinch zoom)
+        if e.type() == QEvent.Type.NativeGesture:
+            gesture_type = e.gestureType()
+
+            if gesture_type == Qt.NativeGestureType.BeginNativeGesture:
+                # Start of pinch gesture - store initial scale
+                self._gesture_zoom_start = self.scale
+                e.accept()
+                return True
+
+            elif gesture_type == Qt.NativeGestureType.ZoomNativeGesture:
+                # Ongoing pinch zoom - value() is cumulative scale factor
+                # Typical values: -0.5 to +0.5 for moderate pinches
+                zoom_delta = e.value()
+
+                # Convert delta to zoom factor
+                # Use smaller multiplier for smoother feel (0.5x damping)
+                factor = 1.0 + (zoom_delta * 0.5)
+
+                # Apply incremental zoom
+                self._zoom_at_anchor(factor)
+                e.accept()
+                return True
+
+            elif gesture_type == Qt.NativeGestureType.EndNativeGesture:
+                # End of pinch gesture - cleanup
+                self._gesture_zoom_start = None
+                e.accept()
+                return True
+
+        # Let parent handle all other events
+        return super().event(e)
+
+
+
     def eventFilter(self, obj, ev):
         is_on_view = (obj is self.label) or (obj is self.scroll.viewport())
 
@@ -2557,7 +2596,29 @@ class ImageSubWindow(QWidget):
         # 1) Ctrl + wheel → zoom
         if ev.type() == QEvent.Type.Wheel:
             if ev.modifiers() & Qt.KeyboardModifier.ControlModifier:
-                factor = 1.25 if ev.angleDelta().y() > 0 else 1/1.25
+                # Try pixelDelta first (macOS trackpad gives smooth values)
+                dy = ev.pixelDelta().y()
+
+                if dy != 0:
+                    # Smooth trackpad scrolling: use smaller base factor
+                    # Scale proportionally to delta magnitude for natural feel
+                    # Typical trackpad deltas are 1-10 pixels per event
+                    abs_dy = abs(dy)
+                    if abs_dy <= 3:
+                        base_factor = 1.01  # Very gentle for tiny movements
+                    elif abs_dy <= 10:
+                        base_factor = 1.02  # Gentle for small movements
+                    else:
+                        base_factor = 1.03  # Moderate for larger gestures
+
+                    factor = base_factor if dy > 0 else 1/base_factor
+                else:
+                    # Traditional mouse wheel: use angleDelta with moderate factor
+                    dy = ev.angleDelta().y()
+                    if dy == 0:
+                        return True
+                    # Use 1.15 for mouse wheel (gentler than original 1.25)
+                    factor = 1.15 if dy > 0 else 1/1.15
                 self._zoom_at_anchor(factor)
                 return True
             return False

setiastro/saspro/supernovaasteroidhunter.py

@@ -362,6 +362,9 @@ class SupernovaAsteroidHunterDialog(QDialog):
                  supernova_path=None, wrench_path=None, spinner_path=None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Supernova / Asteroid Hunter"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if supernova_path:
             self.setWindowIcon(QIcon(supernova_path))
         # keep icon path for previews

setiastro/saspro/swap_manager.py

@@ -1,10 +1,5 @@
-import os
-import shutil
-import tempfile
-import uuid
-import pickle
-import atexit
-import threading
+import os, shutil, tempfile, uuid, atexit, threading
+from collections import OrderedDict
 import numpy as np
 
 class SwapManager:
@@ -14,66 +9,110 @@ class SwapManager:
     def __new__(cls, *args, **kwargs):
         with cls._lock:
             if cls._instance is None:
-                cls._instance = super(SwapManager, cls).__new__(cls)
+                cls._instance = super().__new__(cls)
                 cls._instance._initialized = False
         return cls._instance
 
-    def __init__(self):
+    def __init__(self, *, cache_bytes: int = 1_000_000_000):
         if self._initialized:
             return
         self._initialized = True
-        
-        # Create a unique temp directory for this session
-        self.temp_dir = os.path.join(tempfile.gettempdir(), "SetiAstroSuitePro_Swap", str(uuid.uuid4()))
+
+        self.temp_dir = os.path.join(
+            tempfile.gettempdir(), "SetiAstroSuitePro_Swap", str(uuid.uuid4())
+        )
         os.makedirs(self.temp_dir, exist_ok=True)
-        
-        # Register cleanup on exit
         atexit.register(self.cleanup_all)
 
+        # LRU of in-RAM states: swap_id -> ndarray
+        self._cache = OrderedDict()
+        self._cache_bytes = int(cache_bytes)
+        self._cache_used = 0
+        self._cache_lock = threading.Lock()
+
     def get_swap_path(self, swap_id: str) -> str:
-        return os.path.join(self.temp_dir, f"{swap_id}.swap")
+        # store as .npy (fast + supports mmap)
+        return os.path.join(self.temp_dir, f"{swap_id}.npy")
+
+    def _arr_nbytes(self, a: np.ndarray) -> int:
+        try:
+            return int(a.nbytes)
+        except Exception:
+            return 0
+
+    def _cache_put(self, swap_id: str, arr: np.ndarray):
+        if arr is None:
+            return
+        n = self._arr_nbytes(arr)
+        if n <= 0:
+            return
 
-    def save_state(self, image: np.ndarray) -> str:
-        """
-        Save the image array to a swap file.
-        Returns the unique swap_id.
-        """
+        with self._cache_lock:
+            # If already present, refresh
+            old = self._cache.pop(swap_id, None)
+            if old is not None:
+                self._cache_used -= self._arr_nbytes(old)
+
+            self._cache[swap_id] = arr
+            self._cache_used += n
+
+            # Evict LRU until under budget
+            while self._cache_used > self._cache_bytes and self._cache:
+                k, v = self._cache.popitem(last=False)
+                self._cache_used -= self._arr_nbytes(v)
+
+    def _cache_get(self, swap_id: str):
+        with self._cache_lock:
+            arr = self._cache.pop(swap_id, None)
+            if arr is None:
+                return None
+            # move to MRU
+            self._cache[swap_id] = arr
+            return arr
+
+    def save_state(self, image: np.ndarray) -> str | None:
         swap_id = uuid.uuid4().hex
         path = self.get_swap_path(swap_id)
-        
-        # We only save the image data to disk. Metadata is kept in RAM by the caller.
-        # Using pickle for simplicity and robustness with numpy arrays.
-        # For pure numpy arrays, np.save might be slightly faster, but pickle is more flexible if we change what we store.
-        # Let's stick to pickle for now as per plan.
         try:
-            with open(path, "wb") as f:
-                pickle.dump(image, f, protocol=pickle.HIGHEST_PROTOCOL)
+            # Write fast .npy
+            np.save(path, image, allow_pickle=False)
+            # Optionally keep it hot in RAM too (depends how you use it)
+            self._cache_put(swap_id, image)
+            return swap_id
         except Exception as e:
             print(f"[SwapManager] Failed to save state {swap_id}: {e}")
             return None
-            
-        return swap_id
 
     def load_state(self, swap_id: str) -> np.ndarray | None:
-        """
-        Load the image array from the swap file.
-        """
+        #print("[SwapManager] LOAD", swap_id)
+        # First: try RAM
+        hot = self._cache_get(swap_id)
+        if hot is not None:
+            return hot
+
         path = self.get_swap_path(swap_id)
         if not os.path.exists(path):
             print(f"[SwapManager] Swap file not found: {path}")
             return None
-            
+
         try:
-            with open(path, "rb") as f:
-                return pickle.load(f)
+            # mmap_mode="r" is extremely fast; convert to real ndarray only if needed
+            arr = np.load(path, mmap_mode="r", allow_pickle=False)
+            # If your pipeline needs a writable array, materialize:
+            # arr = np.array(arr, copy=True)
+            # Cache the loaded array (mmap object still OK to cache; you can decide)
+            self._cache_put(swap_id, np.array(arr, copy=False))
+            return np.array(arr, copy=False)
         except Exception as e:
             print(f"[SwapManager] Failed to load state {swap_id}: {e}")
             return None
 
     def delete_state(self, swap_id: str):
-        """
-        Delete a specific swap file.
-        """
+        with self._cache_lock:
+            old = self._cache.pop(swap_id, None)
+            if old is not None:
+                self._cache_used -= self._arr_nbytes(old)
+
         path = self.get_swap_path(swap_id)
         try:
             if os.path.exists(path):
@@ -82,13 +121,9 @@ class SwapManager:
             print(f"[SwapManager] Failed to delete state {swap_id}: {e}")
 
     def cleanup_all(self):
-        """
-        Delete the entire temporary directory for this session.
-        """
         try:
             if os.path.exists(self.temp_dir):
                 shutil.rmtree(self.temp_dir, ignore_errors=True)
-                # print(f"[SwapManager] Cleaned up {self.temp_dir}")
         except Exception as e:
             print(f"[SwapManager] Cleanup failed: {e}")