setiastrosuitepro 1.6.4__py3-none-any.whl → 1.6.10__py3-none-any.whl

setiastro/saspro/supernovaasteroidhunter.py

@@ -24,7 +24,7 @@ from setiastro.saspro.legacy.image_manager import load_image, save_image
 from setiastro.saspro.legacy.numba_utils import bulk_cosmetic_correction_numba
 from setiastro.saspro.imageops.stretch import stretch_mono_image, stretch_color_image
 from setiastro.saspro.star_alignment import PolyGradientRemoval 
-from pro import minorbodycatalog as mbc
+from setiastro.saspro import minorbodycatalog as mbc
 from setiastro.saspro.plate_solver import PlateSolverDialog as PlateSolver
 from setiastro.saspro.widgets.themed_buttons import themed_toolbtn
 

setiastro/saspro/wavescale_hdr.py

@@ -202,7 +202,10 @@ class WaveScaleHDRDialogPro(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self._doc = doc
         base = getattr(doc, "image", None)
         if base is None:

setiastro/saspro/wavescalede.py

@@ -204,7 +204,10 @@ class WaveScaleDarkEnhancerDialogPro(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self._doc = doc
         base = getattr(doc, "image", None)
         if base is None:

setiastro/saspro/whitebalance.py

@@ -88,7 +88,7 @@ def plot_star_color_ratios_comparison(raw_pixels: np.ndarray, after_pixels: np.n
 
     plt.suptitle("Star Color Ratios with RGB Mapping", fontsize=14)
     plt.tight_layout()
-    plt.show()
+    plt.show(block=False)
 
 def apply_manual_white_balance(img: np.ndarray, r_gain: float, g_gain: float, b_gain: float) -> np.ndarray:
     """Simple per-channel gain, clipped to [0,1]."""
@@ -193,16 +193,23 @@ class WhiteBalanceDialog(QDialog):
         super().__init__(parent)
         self._main = parent
         self.doc = doc
-
-        # Connect to active document change signal
+        self._active_doc_conn = False
         if hasattr(self._main, "currentDocumentChanged"):
-            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+            try:
+                self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+                self._active_doc_conn = True
+            except Exception:
+                self._active_doc_conn = False
         if icon:
             self.setWindowIcon(icon)
         self.setWindowTitle(self.tr("White Balance"))
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         self.resize(900, 600)
 
         self._build_ui()
@@ -213,6 +220,8 @@ class WhiteBalanceDialog(QDialog):
         self._update_mode_widgets()
         # kick off a first detection preview
         QTimer.singleShot(200, self._update_star_preview)
+        self.finished.connect(lambda *_: self._cleanup())
+
 
     # ---- UI construction ------------------------------------------------
     def _build_ui(self):
@@ -327,11 +336,16 @@ class WhiteBalanceDialog(QDialog):
             )
             self.star_count.setText(self.tr("Detected {0} stars.").format(count))
             # to pixmap
-            h, w, _ = overlay.shape
-            qimg = QImage((overlay * 255).astype(np.uint8).data, w, h, 3 * w, QImage.Format.Format_RGB888)
-            pm = QPixmap.fromImage(qimg).scaled(self.preview.width(), self.preview.height(),
-                                                Qt.AspectRatioMode.KeepAspectRatio,
-                                                Qt.TransformationMode.SmoothTransformation)
+            overlay8 = np.ascontiguousarray(np.clip(overlay * 255.0, 0, 255).astype(np.uint8))
+            h, w, _ = overlay8.shape
+            qimg = QImage(overlay8.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+
+            # Make sure the numpy buffer stays alive until QPixmap is created
+            pm = QPixmap.fromImage(qimg.copy()).scaled(
+                self.preview.width(), self.preview.height(),
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
             self.preview.setPixmap(pm)
         except Exception as e:
             self.star_count.setText(self.tr("Detection failed."))
@@ -394,7 +408,8 @@ class WhiteBalanceDialog(QDialog):
                 # Use the headless helper so doc metadata is consistent
                 apply_white_balance_to_doc(self.doc, preset)
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
             elif mode == "Auto":
                 preset = {"mode": "auto"}
@@ -404,7 +419,8 @@ class WhiteBalanceDialog(QDialog):
 
                 apply_white_balance_to_doc(self.doc, preset)
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
             else:  # --- Star-Based: compute here so we can plot like SASv2 ---
                 thr   = float(self.thr_slider.value())
@@ -472,7 +488,8 @@ class WhiteBalanceDialog(QDialog):
                     self.tr("Star-Based WB applied.\nDetected {0} stars.").format(int(star_count)),
                 )
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
         except Exception as e:
             QMessageBox.critical(self, self.tr("White Balance"), self.tr("Failed to apply White Balance:\n{0}").format(e))
@@ -490,3 +507,34 @@ class WhiteBalanceDialog(QDialog):
                     self.doc = new_doc
         except Exception:
             pass
+
+    def _finish_and_close(self):
+        """
+        Close this dialog after a successful apply.
+        Use accept() so it behaves like a successful completion.
+        """
+        try:
+            self.accept()
+        except Exception:
+            self.close()
+
+    def _cleanup(self):
+        # Disconnect active-doc signal so the main window doesn't keep us alive
+        try:
+            if self._active_doc_conn and hasattr(self._main, "currentDocumentChanged"):
+                self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        self._active_doc_conn = False
+
+        # Stop debounce timer
+        try:
+            if getattr(self, "_debounce", None) is not None:
+                self._debounce.stop()
+        except Exception:
+            pass
+
+
+    def closeEvent(self, ev):
+        self._cleanup()
+        super().closeEvent(ev)

setiastro/saspro/widgets/common_utilities.py

@@ -1,3 +1,4 @@
+#src/setiastro/saspro/widgets/common_utilities.py
 """
 Common UI utilities and shared components.
 
@@ -220,32 +221,38 @@ _strip_ui_decorations = strip_ui_decorations
 # ---------------------------------------------------------------------------
 
 def install_crash_handlers(app: 'QApplication') -> None:
-    """
-    Install global crash and exception handlers for the application.
-    
-    Sets up:
-    1. faulthandler for hard crashes (segfaults) → saspro_crash.log
-    2. sys.excepthook for uncaught main thread exceptions
-    3. threading.excepthook for uncaught background thread exceptions
-    
-    All exceptions are logged and displayed in a dialog to the user.
-    
-    Args:
-        app: The QApplication instance
-        
-    Example:
-        app = QApplication(sys.argv)
-        install_crash_handlers(app)
-    """
     import faulthandler
-    
-    # 1) Hard crashes (segfaults, access violations) → saspro_crash.log
+    import tempfile
+    from pathlib import Path
+
+    def _get_crash_log_path() -> str:
+        try:
+            if hasattr(sys, "_MEIPASS"):
+                if sys.platform.startswith("win"):
+                    log_dir = Path(os.path.expandvars("%APPDATA%")) / "SetiAstroSuitePro" / "logs"
+                elif sys.platform.startswith("darwin"):
+                    log_dir = Path.home() / "Library" / "Logs" / "SetiAstroSuitePro"
+                else:
+                    log_dir = Path.home() / ".local" / "share" / "SetiAstroSuitePro" / "logs"
+            else:
+                # dev fallback
+                log_dir = Path("logs")
+
+            log_dir.mkdir(parents=True, exist_ok=True)
+            return str(log_dir / "saspro_crash.log")
+        except Exception:
+            return str(Path(tempfile.gettempdir()) / "saspro_crash.log")
+
+    # 1) Hard crashes → saspro_crash.log
     try:
-        _crash_log = open("saspro_crash.log", "w", encoding="utf-8", errors="replace")
+        crash_path = _get_crash_log_path()
+        _crash_log = open(crash_path, "a", encoding="utf-8", errors="replace")
         faulthandler.enable(file=_crash_log, all_threads=True)
         atexit.register(_crash_log.close)
+        logging.info("Faulthandler crash log: %s", crash_path)
     except Exception:
         logging.exception("Failed to enable faulthandler")
+
     
     def _show_dialog(title: str, head: str, details: str) -> None:
         """Show error dialog marshaled to main thread."""
@@ -261,7 +268,7 @@ def install_crash_handlers(app: 'QApplication') -> None:
             m.setStandardButtons(QMessageBox.StandardButton.Ok)
             m.exec()
         QTimer.singleShot(0, _ui)
-    
+
     # 2) Any uncaught exception on the main thread
     def _excepthook(exc_type, exc_value, exc_tb):
         tb = "".join(traceback.format_exception(exc_type, exc_value, exc_tb))

setiastro/saspro/widgets/resource_monitor.py

@@ -5,93 +5,122 @@ import psutil
 from PyQt6.QtCore import Qt, QUrl, QTimer, QObject, pyqtProperty, pyqtSignal, QThread
 from PyQt6.QtWidgets import QWidget, QVBoxLayout, QFrame
 from PyQt6.QtQuickWidgets import QQuickWidget
-
+import time
+import subprocess
 from setiastro.saspro.memory_utils import get_memory_usage_mb
 from setiastro.saspro.resources import _get_base_path
 
+
 class GPUWorker(QThread):
-    """Background worker to monitor GPU without blocking the UI."""
     resultReady = pyqtSignal(float)
 
     def __init__(self, has_nvidia: bool, parent=None):
         super().__init__(parent)
         self._has_nvidia = has_nvidia
-        self._last_val = 0.0
+
+        # cache + throttle (Windows PowerShell is expensive)
+        self._last_win_poll = 0.0
+        self._cached_win_val = 0.0
+
+        self._last_emit = 0.0
+        self._last_emitted_val = None
+
+    def _startupinfo_hidden(self):
+        if os.name != "nt":
+            return None
+        si = subprocess.STARTUPINFO()
+        si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        si.wShowWindow = 0
+        return si
 
     def _get_windows_gpu_load(self) -> float:
-        if os.name != 'nt':
+        if os.name != "nt":
             return 0.0
+
+        now = time.monotonic()
+
+        # THROTTLE: run this at most once every 1.5 seconds
+        if (now - self._last_win_poll) < 1.5:
+            return self._cached_win_val
+
+        self._last_win_poll = now
+
         try:
-            import subprocess
-            # Aggregation logic to match Task Manager:
-            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
-            # 2. Sum utilization of all processes sharing that engine.
-            # 3. Take the Maximum of these sums as the overall GPU load.
-            # Aggregation logic to match Task Manager:
-            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
-            # 2. Sum utilization of all processes sharing that engine.
-            # 3. Take the Maximum of these sums as the overall GPU load.
-            cmd = (
-                "powershell -NoProfile -ExecutionPolicy Bypass -Command \""
-                "$groups = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine -ErrorAction SilentlyContinue | "
-                "Group-Object -Property { $_.Name -replace '^pid_\\d+_', '' }; "
-                "$res_list = $groups | ForEach-Object { ($_.Group | Measure-Object -Property UtilizationPercentage -Sum).Sum }; "
-                "$max_val = ($res_list | Measure-Object -Maximum).Maximum; "
-                "if ($max_val) { [math]::Round($max_val, 1) } else { 0 }\""
+            # Use explicit powershell.exe and make it non-interactive + hidden
+            cmd = [
+                "powershell.exe",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy", "Bypass",
+                "-Command",
+                (
+                    "$x = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine "
+                    "-ErrorAction SilentlyContinue; "
+                    "if (-not $x) { 0 } else { "
+                    "  $m = ($x | Measure-Object -Property UtilizationPercentage -Maximum).Maximum; "
+                    "  if ($m) { [math]::Round([double]$m, 1) } else { 0 } "
+                    "}"
+                ),
+            ]
+
+            out = subprocess.check_output(
+                cmd,
+                startupinfo=self._startupinfo_hidden(),
+                timeout=2.0,               # IMPORTANT: don’t allow 5s hangs
+                stderr=subprocess.DEVNULL,  # keep it quiet
             )
-            startupinfo = subprocess.STARTUPINFO()
-            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-            startupinfo.wShowWindow = 0 
-            
-            out = subprocess.check_output(cmd, startupinfo=startupinfo, timeout=5.0)
-            val_str = out.decode("utf-8").strip()
-            
-            if not val_str: return 0.0
-            return float(val_str.replace(",", "."))
+            val_str = out.decode("utf-8", errors="ignore").strip()
+
+            val = float(val_str.replace(",", ".")) if val_str else 0.0
+            self._cached_win_val = val
+            return val
         except Exception:
-            return 0.0
+            # keep last known value instead of spamming 0.0
+            return self._cached_win_val
 
     def _get_gpu_load(self) -> float:
         nv_val = 0.0
         win_val = 0.0
-        
-        # 1. Check NVIDIA (Discrete)
+
+        # NVIDIA (fast, keep it)
         if self._has_nvidia:
             try:
-                import subprocess
-                startupinfo = None
-                if os.name == 'nt':
-                    startupinfo = subprocess.STARTUPINFO()
-                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-                    startupinfo.wShowWindow = 0 
-
                 out = subprocess.check_output(
                     ["nvidia-smi", "--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
-                    startupinfo=startupinfo,
-                    timeout=0.6
+                    startupinfo=self._startupinfo_hidden(),
+                    timeout=0.6,
+                    stderr=subprocess.DEVNULL,
                 )
-                line = out.decode("utf-8").strip().split('\n')[0]
+                line = out.decode("utf-8", errors="ignore").strip().split("\n")[0]
                 nv_val = float(line)
             except Exception:
-                pass 
-        
-        # 2. Check Universal (Integrated)
-        if os.name == 'nt':
+                pass
+
+        # Windows integrated (slow, throttled)
+        if os.name == "nt":
             win_val = self._get_windows_gpu_load()
-            
+
         return max(nv_val, win_val)
 
     def run(self):
         while not self.isInterruptionRequested():
             try:
                 val = self._get_gpu_load()
-                self.resultReady.emit(val)
-                # Sleep between measurements. 250ms as requested.
-                # Note: PowerShell queries might take longer than 250ms, 
-                # but this loop will run as fast as the hardware allows without blocking UI.
+
+                # Optional: emit only if value changed a bit, or once per 250ms max
+                now = time.monotonic()
+                if (
+                    self._last_emitted_val is None
+                    or abs(val - self._last_emitted_val) >= 1.0
+                    or (now - self._last_emit) >= 0.5
+                ):
+                    self._last_emit = now
+                    self._last_emitted_val = val
+                    self.resultReady.emit(val)
+
                 self.msleep(250)
             except Exception:
-                self.msleep(1000) # Error backoff on failure
+                self.msleep(1000)
 
 class ResourceBackend(QObject):
     """Backend logic for the QML Resource Monitor."""
@@ -197,6 +226,7 @@ class SystemMonitorWidget(QQuickWidget):
         self.setAttribute(Qt.WidgetAttribute.WA_AlwaysStackOnTop, False)
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
         self.setClearColor(Qt.GlobalColor.transparent)
+        self._qml_push_pending = False
 
         # Connect Backend
         self.backend = ResourceBackend(self)
@@ -218,16 +248,23 @@ class SystemMonitorWidget(QQuickWidget):
         # Let's re-write the QML loading part to use a safer 'initialProperties' approach or just signal/slots.
         #
         # EASIEST: QML binds to `root.cpuUsage`. Python sets `root.cpuUsage`.
-        
-        self.backend.cpuChanged.connect(self._push_data_to_qml)
-        self.backend.ramChanged.connect(self._push_data_to_qml)
-        self.backend.gpuChanged.connect(self._push_data_to_qml)
-        self.backend.appRamChanged.connect(self._push_data_to_qml)
+
         
         # Load QML
         qml_path = os.path.join(_get_base_path(), "qml", "ResourceMonitor.qml")
         self.setSource(QUrl.fromLocalFile(qml_path))
 
+    def _schedule_qml_push(self):
+        if self._qml_push_pending:
+            return
+        self._qml_push_pending = True
+        QTimer.singleShot(0, self._push_data_to_qml_coalesced)
+
+    def _push_data_to_qml_coalesced(self):
+        self._qml_push_pending = False
+        self._push_data_to_qml()
+
+
     def _push_data_to_qml(self):
         root = self.rootObject()
         if root:
@@ -239,10 +276,23 @@ class SystemMonitorWidget(QQuickWidget):
     # --- Drag & Drop Support ---
     def mousePressEvent(self, event):
         if event.button() == Qt.MouseButton.LeftButton:
+            # Wayland-friendly: ask compositor to move the window
+            wh = self.windowHandle()
+            if wh is not None:
+                try:
+                    # Works best for frameless overlays on Wayland
+                    wh.startSystemMove()
+                    event.accept()
+                    return
+                except Exception:
+                    pass
+
+            # Fallback (Windows/X11): manual move tracking
             self._drag_start_pos = event.globalPosition().toPoint() - self.frameGeometry().topLeft()
             event.accept()
-        else:
-            super().mousePressEvent(event)
+            return
+
+        super().mousePressEvent(event)
 
     def mouseMoveEvent(self, event):
         if event.buttons() & Qt.MouseButton.LeftButton:

setiastro/saspro/widgets/spinboxes.py

@@ -37,7 +37,7 @@ class CustomSpinBox(QWidget):
         self.minimum = minimum
         self.maximum = maximum
         self.step = step
-        self._value = initial
+        self._value = int(initial)
 
         # Line edit for value display/entry
         self.lineEdit = QLineEdit(str(initial))
@@ -77,14 +77,13 @@ class CustomSpinBox(QWidget):
 
         self._update_button_states()
 
-    @property
     def value(self) -> int:
-        """Get the current value."""
-        return self._value
+        """Qt-style getter."""
+        return int(self._value)
 
     def setValue(self, val: int) -> None:
-        """Set the value, clamping to min/max."""
-        val = max(self.minimum, min(self.maximum, val))
+        val = int(val)
+        val = max(int(self.minimum), min(int(self.maximum), val))
         if val != self._value:
             self._value = val
             self.lineEdit.setText(str(val))
@@ -144,7 +143,6 @@ class CustomSpinBox(QWidget):
         return self._value
 
     def _update_button_states(self) -> None:
-        """Enable/disable buttons at limits."""
         self.upButton.setEnabled(self._value < self.maximum)
         self.downButton.setEnabled(self._value > self.minimum)
 
@@ -175,7 +173,7 @@ class CustomDoubleSpinBox(QWidget):
         self.maximum = maximum
         self.step = step
         self.decimals = decimals
-        self._value = initial
+        self._value = float(initial)
 
         # Line edit for value display/entry
         self.lineEdit = QLineEdit(f"{initial:.{decimals}f}")
@@ -215,14 +213,13 @@ class CustomDoubleSpinBox(QWidget):
 
         self._update_button_states()
 
-    @property
     def value(self) -> float:
-        """Get the current value."""
-        return self._value
+        """Qt-style getter."""
+        return float(self._value)
 
     def setValue(self, val: float) -> None:
-        """Set the value, clamping to min/max."""
-        val = max(self.minimum, min(self.maximum, val))
+        val = float(val)
+        val = max(float(self.minimum), min(float(self.maximum), val))
         if abs(val - self._value) > 1e-10:
             self._value = val
             self.lineEdit.setText(f"{val:.{self.decimals}f}")