setiastrosuitepro 1.6.5.post3__tar.gz → 1.6.6.post1__tar.gz

{setiastrosuitepro-1.6.5.post3 → setiastrosuitepro-1.6.6.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setiastrosuitepro
-Version: 1.6.5.post3
+Version: 1.6.6.post1
 Summary: Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization
 License: GPL-3.0
 License-File: LICENSE
@@ -25,6 +25,7 @@ Requires-Dist: astroalign
 Requires-Dist: astropy
 Requires-Dist: astroquery
 Requires-Dist: exifread
+Requires-Dist: imagecodecs (>=2025.11.11,<2026.0.0) ; python_version >= "3.11" and sys_platform == "darwin"
 Requires-Dist: imageio
 Requires-Dist: jplephem
 Requires-Dist: lightkurve

{setiastrosuitepro-1.6.5.post3 → setiastrosuitepro-1.6.6.post1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "setiastrosuitepro"
-version = "1.6.5.post3"
+version = "1.6.6.post1"
 description = "Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization"
 authors = ["Franklin Marek <info@setiastro.com>"]
 readme = "README.md"
@@ -77,6 +77,7 @@ psutil = "*"
 
 # computer vision
 opencv-python-headless = "*"
+imagecodecs = {version = "^2025.11.11", python = ">=3.11", platform = "darwin"}
 
 [tool.poetry.group.dev.dependencies]
 pytest = "*"

setiastrosuitepro-1.6.6.post1/src/setiastro/qml/ResourceMonitor.qml

@@ -0,0 +1,128 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Window 2.15   // ✅ gives us access to the attached Window handle
+
+Rectangle {
+    id: root
+    width: 200
+    height: 60
+    color: "#80000000"
+    radius: 30
+    border.color: "#555"
+    border.width: 1
+
+    // Bind directly to the injected Python object (context property "backend")
+    property double cpuUsage: backend ? backend.cpuUsage : 0.0
+    property double ramUsage: backend ? backend.ramUsage : 0.0
+    property double gpuUsage: backend ? backend.gpuUsage : 0.0
+    property string appRamString: backend ? backend.appRamString : "0 MB"
+
+    // ─── Wayland-friendly drag (works if we have a real QQuickWindow) ───
+    MouseArea {
+        anchors.fill: parent
+        hoverEnabled: true
+        cursorShape: Qt.OpenHandCursor
+
+        onPressed: {
+            // Window-attached handle: root.Window.window is the QQuickWindow
+            var w = root.Window ? root.Window.window : null;
+            if (w && w.startSystemMove) {
+                // Wayland: this is the correct, compositor-approved move
+                w.startSystemMove();
+            } else {
+                // Fallback (Windows embed, or platforms where startSystemMove isn't exposed)
+                // Do nothing; your existing Windows behavior remains unchanged.
+            }
+        }
+    }
+
+    component MiniGauge: Item {
+        Layout.preferredWidth: 40
+        Layout.preferredHeight: 40
+        property string label: ""
+        property color barColor: "#0f0"
+        property double value: 0
+
+        onValueChanged: if (gaugeCanvas) gaugeCanvas.requestPaint()
+
+        Canvas {
+            id: gaugeCanvas
+            anchors.fill: parent
+            antialiasing: true
+            onPaint: {
+                var ctx = getContext("2d");
+                var cx = width / 2;
+                var cy = height / 2;
+                var r = (width / 2) - 3;
+
+                ctx.reset();
+
+                ctx.beginPath();
+                ctx.arc(cx, cy, r, 0, 2*Math.PI);
+                ctx.lineWidth = 4;
+                ctx.strokeStyle = "#444";
+                ctx.stroke();
+
+                var start = -Math.PI/2;
+                var end = start + (value/100 * 2*Math.PI);
+
+                ctx.beginPath();
+                ctx.arc(cx, cy, r, start, end);
+                ctx.lineWidth = 4;
+                ctx.lineCap = "round";
+                ctx.strokeStyle = barColor;
+                ctx.stroke();
+            }
+        }
+
+        Text {
+            anchors.centerIn: parent
+            text: Math.round(value) + "%"
+            font.pixelSize: 10
+            font.bold: true
+            color: "#fff"
+        }
+    }
+
+    RowLayout {
+        anchors.centerIn: parent
+        spacing: 15
+
+        ColumnLayout {
+            spacing: 2
+            MiniGauge {
+                value: root.cpuUsage
+                barColor: root.cpuUsage > 80 ? "#ff4444" : (root.cpuUsage > 50 ? "#ffbb33" : "#00C851")
+            }
+            Text {
+                Layout.alignment: Qt.AlignHCenter
+                text: "CPU"
+                color: "#aaaaaa"
+                font.pixelSize: 9
+            }
+        }
+
+        ColumnLayout {
+            spacing: 2
+            MiniGauge { value: root.ramUsage; barColor: "#33b5e5" }
+            Text {
+                Layout.alignment: Qt.AlignHCenter
+                text: "RAM"
+                color: "#aaaaaa"
+                font.pixelSize: 9
+            }
+        }
+
+        ColumnLayout {
+            spacing: 2
+            MiniGauge { value: root.gpuUsage; barColor: "#aa66cc" }
+            Text {
+                Layout.alignment: Qt.AlignHCenter
+                text: "GPU"
+                color: "#aaaaaa"
+                font.pixelSize: 9
+            }
+        }
+    }
+}

{setiastrosuitepro-1.6.5.post3 → setiastrosuitepro-1.6.6.post1}/src/setiastro/saspro/__main__.py

@@ -92,9 +92,15 @@ def _init_splash():
     # Create QApplication
     _app = QApplication(sys.argv)
     
+    try:
+        _app.setQuitOnLastWindowClosed(True)
+    except Exception:
+        pass
+
     if sys.platform.startswith("linux"):
         try:
             print("Qt platform:", _app.platformName())
+            print("QuitOnLastWindowClosed:", _app.quitOnLastWindowClosed())
             print("XDG_SESSION_TYPE:", os.environ.get("XDG_SESSION_TYPE"))
             print("QT_QPA_PLATFORM:", os.environ.get("QT_QPA_PLATFORM"))
             print("QT_OPENGL:", os.environ.get("QT_OPENGL"))

setiastrosuitepro-1.6.6.post1/src/setiastro/saspro/_generated/build_info.py

@@ -0,0 +1,3 @@
+# Auto-generated at build time. Do not edit.
+BUILD_TIMESTAMP = "2025-12-30T18:14:14Z"
+APP_VERSION = "1.6.7"

{setiastrosuitepro-1.6.5.post3 → setiastrosuitepro-1.6.6.post1}/src/setiastro/saspro/abe.py

@@ -491,14 +491,21 @@ class ABEDialog(QDialog):
         # Non-modal: allow user to switch between images while dialog is open
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
-        #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
 
         self._main = parent
         self.doc = document
 
-        # Connect to active document change signal
+        self._connected_current_doc_changed = 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._connected_current_doc_changed = True
+            except Exception:
+                self._connected_current_doc_changed = False
 
         self._preview_scale = 1.0
         self._preview_qimg = None
@@ -844,12 +851,38 @@ class ABEDialog(QDialog):
             self._set_status("Done")
             # Dialog stays open so user can apply to other images
             # Refresh to use the now-active document for next operation
-            self._refresh_document_from_active()
+            self.close()
+            return
 
         except Exception as e:
             self._set_status("Error")
             QMessageBox.critical(self, "Apply failed", str(e))
 
+    def closeEvent(self, ev):
+        # 1) Disconnect active-doc tracking (Fabio hook)
+        try:
+            if self._connected_current_doc_changed and hasattr(self._main, "currentDocumentChanged"):
+                self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        self._connected_current_doc_changed = False
+
+        # 2) Stop any background preview worker/thread if you have one
+        # (names may differ in your file; keep what matches your implementation)
+        try:
+            if getattr(self, "_worker", None) is not None:
+                try:
+                    self._worker.requestInterruption()
+                except Exception:
+                    pass
+            if getattr(self, "_thread", None) is not None:
+                self._thread.quit()
+                self._thread.wait(500)
+        except Exception:
+            pass
+
+        super().closeEvent(ev)
+
     def _refresh_document_from_active(self):
         """
         Refresh the dialog's document reference to the currently active document.

{setiastrosuitepro-1.6.5.post3 → setiastrosuitepro-1.6.6.post1}/src/setiastro/saspro/aberration_ai.py

@@ -13,7 +13,7 @@ IS_APPLE_ARM = (sys.platform == "darwin" and platform.machine() == "arm64")
 from PyQt6.QtCore import Qt, QThread, pyqtSignal, QStandardPaths, QSettings
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QFileDialog,
-    QComboBox, QSpinBox, QProgressBar, QMessageBox, QCheckBox
+    QComboBox, QSpinBox, QProgressBar, QMessageBox, QCheckBox, QLineEdit
 )
 from PyQt6.QtGui import QIcon
 from setiastro.saspro.config import Config
@@ -315,11 +315,29 @@ class AberrationAIDialog(QDialog):
         row.addWidget(QLabel(self.tr("Model:")))
         self.model_label = QLabel("—")
         self.model_label.setToolTip("")
-        btn_browse = QPushButton(self.tr("Browse…")); btn_browse.clicked.connect(self._browse_model)
+        btn_browse = QPushButton(self.tr("Browse…")); btn_browse.clicked.connect(self._browse_active_model)
         row.addWidget(self.model_label, 1)
         row.addWidget(btn_browse)
         v.addLayout(row)
+        # Custom model row (NEW)
+        row_custom = QHBoxLayout()
+        self.chk_use_custom = QCheckBox(self.tr("Use custom model file"))
+        self.chk_use_custom.setChecked(False)
+        self.chk_use_custom.toggled.connect(self._on_use_custom_toggled)
 
+        self.le_custom_model = QLineEdit()
+        self.le_custom_model.setReadOnly(True)
+        self.le_custom_model.setPlaceholderText(self.tr("No custom model selected"))
+        self.le_custom_model.setToolTip("")
+
+        btn_custom_clear = QPushButton(self.tr("Clear"))
+        btn_custom_clear.clicked.connect(self._clear_custom_model)
+
+        row_custom.addWidget(self.chk_use_custom)
+        row_custom.addWidget(self.le_custom_model, 1)
+
+        row_custom.addWidget(btn_custom_clear)
+        v.addLayout(row_custom)
         # Providers row
         row2 = QHBoxLayout()
         self.chk_auto = QCheckBox(self.tr("Auto GPU (if available)"))
@@ -373,7 +391,9 @@ class AberrationAIDialog(QDialog):
         self._model_path = None
         self._refresh_providers()
         self._load_last_model_from_settings()
-
+        self._load_last_custom_model_from_settings()
+        use_custom = QSettings().value("AberrationAI/use_custom_model", False, type=bool)
+        self.chk_use_custom.setChecked(bool(use_custom))
         if IS_APPLE_ARM:
             self.chk_auto.setChecked(False)
             self.chk_auto.setEnabled(False)
@@ -395,11 +415,73 @@ class AberrationAIDialog(QDialog):
         if p and os.path.isfile(p):
             self._set_model_path(p)
 
-    def _browse_model(self):
-        start_dir = _app_model_dir()
+    def _browse_active_model(self):
+        """
+        Single Browse button.
+        - If user picks a file inside the app model folder -> treat as "downloaded" selection (use_custom_model=False)
+        - If user picks a file outside -> treat as "custom" (use_custom_model=True)
+        """
+        app_dir = os.path.abspath(_app_model_dir())
+
+        # Start in last-used folder if possible
+        last_custom = QSettings().value("AberrationAI/custom_model_path", type=str) or ""
+        last_downloaded = QSettings().value("AberrationAI/model_path", type=str) or ""
+        start_dir = None
+        for candidate in (last_custom, last_downloaded):
+            if candidate and os.path.isfile(candidate):
+                d = os.path.dirname(candidate)
+                if os.path.isdir(d):
+                    start_dir = d
+                    break
+        if start_dir is None:
+            start_dir = app_dir
+
         p, _ = QFileDialog.getOpenFileName(self, "Select ONNX model", start_dir, "ONNX (*.onnx)")
-        if p:
-            self._set_model_path(p)
+        if not p:
+            return
+
+        p_abs = os.path.abspath(p)
+        # Determine if picked file is inside app model folder
+        in_app_dir = False
+        try:
+            in_app_dir = os.path.commonpath([app_dir, p_abs]) == app_dir
+        except Exception:
+            in_app_dir = p_abs.startswith(app_dir)
+
+        if in_app_dir:
+            # "Downloaded" selection
+            self._set_model_path(p_abs)
+            self._set_custom_model_path(None)
+            QSettings().setValue("AberrationAI/use_custom_model", False)
+            if hasattr(self, "chk_use_custom"):
+                self.chk_use_custom.setChecked(False)
+        else:
+            # "Custom" selection
+            self._set_custom_model_path(p_abs)
+            QSettings().setValue("AberrationAI/use_custom_model", True)
+            if hasattr(self, "chk_use_custom"):
+                self.chk_use_custom.setChecked(True)
+
+        # Keep visuals in sync
+        self._refresh_model_label()
+        self._refresh_custom_row_visibility()
+
+
+    def _refresh_model_label(self):
+        downloaded = QSettings().value("AberrationAI/model_path", type=str) or ""
+        custom     = QSettings().value("AberrationAI/custom_model_path", type=str) or ""
+        use_custom = QSettings().value("AberrationAI/use_custom_model", False, type=bool)
+
+        if use_custom and custom:
+            self.model_label.setText(f"Custom: {os.path.basename(custom)}")
+            self.model_label.setToolTip(custom)
+        elif downloaded:
+            self.model_label.setText(f"Downloaded: {os.path.basename(downloaded)}")
+            self.model_label.setToolTip(downloaded)
+        else:
+            self.model_label.setText("—")
+            self.model_label.setToolTip("")
+
 
     def _open_model_folder(self):
         d = _app_model_dir()
@@ -412,6 +494,108 @@ class AberrationAIDialog(QDialog):
                 import subprocess; subprocess.Popen(["xdg-open", d])
         except Exception:
             webbrowser.open(f"file://{d}")
+    # ----- custom model helpers (NEW) -----
+    def _set_custom_model_path(self, p: str | None):
+        if p:
+            self.le_custom_model.setText(os.path.basename(p))
+            self.le_custom_model.setToolTip(p)
+            QSettings().setValue("AberrationAI/custom_model_path", p)
+        else:
+            self.le_custom_model.clear()
+            self.le_custom_model.setToolTip("")
+            QSettings().remove("AberrationAI/custom_model_path")
+
+    def _load_last_custom_model_from_settings(self):
+        p = QSettings().value("AberrationAI/custom_model_path", type=str)
+        if p:
+            if os.path.isfile(p):
+                self._set_custom_model_path(p)
+            else:
+                # Keep the broken path visible in tooltip for debugging
+                if hasattr(self, "le_custom_model"):
+                    self.le_custom_model.setText(os.path.basename(p) + "  (missing)")
+                    self.le_custom_model.setToolTip(p)
+
+        # After both loads, sync labels/visibility
+        self._refresh_model_label()
+        self._refresh_custom_row_visibility()
+
+    def _refresh_custom_row_visibility(self):
+        """
+        If you keep the custom row in the UI, hide the path field unless custom is enabled.
+        """
+        if not hasattr(self, "le_custom_model"):
+            return
+        use_custom = QSettings().value("AberrationAI/use_custom_model", False, type=bool)
+        self.le_custom_model.setVisible(bool(use_custom))
+
+
+    def _refresh_model_label(self):
+        downloaded = QSettings().value("AberrationAI/model_path", type=str) or ""
+        custom     = QSettings().value("AberrationAI/custom_model_path", type=str) or ""
+        use_custom = QSettings().value("AberrationAI/use_custom_model", False, type=bool)
+
+        # Prefer custom only if enabled AND the file exists
+        if use_custom and custom:
+            if os.path.isfile(custom):
+                self.model_label.setText(f"Custom: {os.path.basename(custom)}")
+                self.model_label.setToolTip(custom)
+                return
+            else:
+                self.model_label.setText(f"Custom: {os.path.basename(custom)}  (missing)")
+                self.model_label.setToolTip(custom)
+                return
+
+        # Otherwise show downloaded if valid
+        if downloaded and os.path.isfile(downloaded):
+            self.model_label.setText(f"Downloaded: {os.path.basename(downloaded)}")
+            self.model_label.setToolTip(downloaded)
+        else:
+            self.model_label.setText("—")
+            self.model_label.setToolTip("")
+
+
+    def _browse_custom_model(self):
+        # Start at last dir if possible, else app model dir
+        last = QSettings().value("AberrationAI/custom_model_path", type=str) or ""
+        start_dir = os.path.dirname(last) if last and os.path.isdir(os.path.dirname(last)) else _app_model_dir()
+        p, _ = QFileDialog.getOpenFileName(self, "Select custom ONNX model", start_dir, "ONNX (*.onnx)")
+        if p:
+            self._set_custom_model_path(p)
+            QSettings().setValue("AberrationAI/use_custom_model", True)
+            if not self.chk_use_custom.isChecked():
+                self.chk_use_custom.setChecked(True)
+
+    def _clear_custom_model(self):
+        self._set_custom_model_path(None)
+        QSettings().setValue("AberrationAI/use_custom_model", False)
+        if hasattr(self, "chk_use_custom"):
+            self.chk_use_custom.setChecked(False)
+
+        self._refresh_model_label()
+        self._refresh_custom_row_visibility()
+
+
+    def _on_use_custom_toggled(self, on: bool):
+        QSettings().setValue("AberrationAI/use_custom_model", bool(on))
+
+        if on:
+            p = QSettings().value("AberrationAI/custom_model_path", type=str) or ""
+            if not (p and os.path.isfile(p)):
+                # Don’t spawn another browse button path; use the ONE browse if they want
+                QMessageBox.information(
+                    self,
+                    self.tr("Custom model"),
+                    self.tr("Custom model is enabled, but no custom file is selected.\n"
+                            "Click Browse… to choose a model file.")
+                )
+                # Optional: auto-open the single browse:
+                # self._browse_active_model()
+                # return
+
+        self._refresh_model_label()
+        self._refresh_custom_row_visibility()
+
 
     # ----- provider UI -----
     def _log(self, msg: str):  # NEW
@@ -477,8 +661,16 @@ class AberrationAIDialog(QDialog):
     def _on_download_ok(self, path: str):
         self.progress.setValue(100)
         self._set_model_path(path)
+
+        # Download becomes the active model unless custom is explicitly enabled
+        if not QSettings().value("AberrationAI/use_custom_model", False, type=bool):
+            self._set_custom_model_path(None)
+
         QMessageBox.information(self, "Model", f"Downloaded: {os.path.basename(path)}")
 
+        self._refresh_model_label()
+        self._refresh_custom_row_visibility()
+
     # ----- run -----
     def _run(self):
         if ort is None:
@@ -489,7 +681,22 @@ class AberrationAIDialog(QDialog):
                 "Please try installing an earlier version (for example 1.19.x) and try again."
             )
             return
-        if not self._model_path or not os.path.isfile(self._model_path):
+        
+        # Choose model path (normal vs custom)
+        use_custom = QSettings().value("AberrationAI/use_custom_model", False, type=bool)
+        downloaded = QSettings().value("AberrationAI/model_path", type=str) or ""
+        custom     = QSettings().value("AberrationAI/custom_model_path", type=str) or ""
+
+        model_path = custom if use_custom else downloaded
+        if self.chk_use_custom.isChecked():
+            cp = QSettings().value("AberrationAI/custom_model_path", type=str)
+            if cp and os.path.isfile(cp):
+                model_path = cp
+            else:
+                QMessageBox.warning(self, "Model", "Custom model is enabled but the file is missing. Please browse to a valid .onnx.")
+                return
+
+        if not model_path or not os.path.isfile(model_path):
             QMessageBox.warning(self, "Model", "Please select or download a valid .onnx model first.")
             return
 
@@ -516,7 +723,7 @@ class AberrationAIDialog(QDialog):
                 providers = [sel] if sel else ["CPUExecutionProvider"]
 
         # --- make patch match the model's requirement (if fixed) ---
-        req = _model_required_patch(self._model_path)
+        req = _model_required_patch(model_path)
         if req and req > 0:
             patch = req
             try:
@@ -537,14 +744,16 @@ class AberrationAIDialog(QDialog):
 
         self._t_start = time.perf_counter()
         prov_txt = ("auto" if self.chk_auto.isChecked() else self.cmb_provider.currentText() or "CPU")
-        self._log(f"🚀 Aberration AI: model={os.path.basename(self._model_path)}, "
+        self._log(f"🚀 Aberration AI: model={os.path.basename(model_path)}, "
                   f"provider={prov_txt}, patch={patch}, overlap={overlap}")
+        
+        self._effective_model_path = model_path
 
         # -------- run worker --------
         self.progress.setValue(0)
         self.btn_run.setEnabled(False)
 
-        self._worker = _ONNXWorker(self._model_path, img, patch, overlap, providers)
+        self._worker = _ONNXWorker(model_path, img, patch, overlap, providers)
         self._worker.progressed.connect(self.progress.setValue)
         self._worker.failed.connect(self._on_failed)
         self._worker.finished_ok.connect(self._on_ok)
@@ -553,11 +762,15 @@ class AberrationAIDialog(QDialog):
 
 
     def _on_failed(self, msg: str):
+        model_path = getattr(self, "_effective_model_path", self._model_path)
         self._log(f"❌ Aberration AI failed: {msg}")
         QMessageBox.critical(self, "ONNX Error", msg)
         self.reject()   # closes the dialog
 
     def _on_ok(self, out: np.ndarray):
+        used = getattr(self._worker, "used_provider", None) or \
+            (self.cmb_provider.currentText() if not self.chk_auto.isChecked() else "auto")        
+        model_path = getattr(self, "_effective_model_path", self._model_path)
         doc = self.get_active_doc()
         if doc is None or getattr(doc, "image", None) is None:
             QMessageBox.warning(self, "Image", "No active image.")
@@ -579,11 +792,10 @@ class AberrationAIDialog(QDialog):
             "processing_parameters": {
                 **(getattr(doc, "metadata", {}) or {}).get("processing_parameters", {}),
                 "AberrationAI": {
-                    "model_path": self._model_path,
+                    "model_path": model_path,
                     "patch_size": int(self.spin_patch.value()),
                     "overlap": int(self.spin_overlap.value()),
-                    "provider": (self.cmb_provider.currentText()
-                                if not self.chk_auto.isChecked() else "auto"),
+                    "provider": used,
                     "border_px": BORDER_PX,
                 }
             }
@@ -616,7 +828,7 @@ class AberrationAIDialog(QDialog):
             if main is not None:
                 auto_gpu = bool(self.chk_auto.isChecked())
                 preset = {
-                    "model": self._model_path,
+                    "model": model_path,
                     "patch": int(self.spin_patch.value()),
                     "overlap": int(self.spin_overlap.value()),
                     "border_px": int(BORDER_PX),
@@ -675,7 +887,7 @@ class AberrationAIDialog(QDialog):
         BORDER_PX = 10  # same value used above
         self._log(
             f"✅ Aberration AI applied "
-            f"(model={os.path.basename(self._model_path)}, provider={used}, "
+            f"(model={os.path.basename(model_path)}, provider={used}, "
             f"patch={int(self.spin_patch.value())}, overlap={int(self.spin_overlap.value())}, "
             f"border={BORDER_PX}px, time={dt:.2f}s)"
         )