setiastrosuitepro 1.6.7__py3-none-any.whl → 1.7.0__py3-none-any.whl

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -12,6 +12,7 @@ from PyQt6.QtWidgets import QMenu, QToolButton
 
 from PyQt6.QtCore import QElapsedTimer
 
+import sys
 
 if TYPE_CHECKING:
     pass
@@ -30,10 +31,10 @@ from setiastro.saspro.resources import (
     stacking_path, pedestal_icon_path, starspike_path, astrospike_path,
     signature_icon_path, livestacking_path, convoicon_path, spcc_icon_path,
     exoicon_path, peeker_icon, dse_icon_path, isophote_path, statstretch_path,
-    starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path,
+    starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path, narrowbandnormalization_path,
     nbtorgb_path, freqsep_path, multiscale_decomp_path, contsub_path, halo_path, cosmic_path,
     satellite_path, imagecombine_path, wims_path, wimi_path, linearfit_path,
-    debayer_path, aberration_path, functionbundles_path, viewbundles_path,
+    debayer_path, aberration_path, functionbundles_path, viewbundles_path, planetarystacker_path,
     selectivecolor_path, rgbalign_path,
 )
 
@@ -255,6 +256,7 @@ class ToolbarMixin:
         tb_tl.addAction(self.act_blink)  # Tools start here; Blink shows with QIcon(blink_path)
         tb_tl.addAction(self.act_ppp)    # Perfect Palette Picker
         tb_tl.addAction(self.act_nbtorgb)
+        tb_tl.addAction(self.act_narrowband_normalization)
         tb_tl.addAction(self.act_selective_color)
         tb_tl.addAction(self.act_freqsep)
         tb_tl.addAction(self.act_multiscale_decomp)
@@ -301,6 +303,7 @@ class ToolbarMixin:
         tb_star.addAction(self.act_psf_viewer)
         tb_star.addAction(self.act_stacking_suite)
         tb_star.addAction(self.act_live_stacking)
+        tb_star.addAction(self.act_planetary_stacker)
         tb_star.addAction(self.act_plate_solve)
         tb_star.addAction(self.act_star_align)
         tb_star.addAction(self.act_star_register)
@@ -366,6 +369,7 @@ class ToolbarMixin:
         tb_hidden.setObjectName("Hidden")
         tb_hidden.setSettingsKey("Toolbar/Hidden")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_hidden)
+        #tb_hidden.addAction(self.act_narrowband_normalization)
         tb_hidden.setVisible(False)  # <- always hidden
 
         # This can move actions between toolbars, so do it after each toolbar has its base order restored.
@@ -594,7 +598,16 @@ class ToolbarMixin:
                 fit_menu.addAction(self.act_auto_fit_resize)  # use the real action
                 btn_fit.setMenu(fit_menu)
                 btn_fit.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
+        tb = self._toolbar_containing_action(self.act_autostretch)
+        if tb:
+            btn = tb.widgetForAction(self.act_autostretch)
+            if isinstance(btn, QToolButton):
+                # ... build menu ...
+                btn.setMenu(menu)
+                btn.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
 
+                # IMPORTANT: re-apply style after action moves / rebind
+                self._style_toggle_toolbutton(btn)
 
     def _bind_view_toolbar_menus(self, tb: DraggableToolBar):
         # --- Display-Stretch menu ---
@@ -650,6 +663,12 @@ class ToolbarMixin:
             btn_fit.setMenu(fit_menu)
             btn_fit.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
 
+    def _linux_force_text_action(self, act: QAction, text: str) -> None:
+        """On Linux, show text-only for this action (no theme icon)."""
+        if not sys.platform.startswith("linux"):
+            return
+        act.setIcon(QIcon())   # remove whatever theme icon got assigned
+        act.setText(text)      # show the glyph/text
 
     def _create_actions(self):
         # File actions
@@ -771,30 +790,30 @@ class ToolbarMixin:
         self.act_bake_display_stretch.triggered.connect(self._bake_display_stretch)
 
         # --- Zoom controls ---
-        # --- Zoom controls (themed icons) ---
         self.act_zoom_out = QAction(QIcon.fromTheme("zoom-out"), self.tr("Zoom Out"), self)
         self.act_zoom_out.setStatusTip(self.tr("Zoom out"))
         self.act_zoom_out.setShortcuts([QKeySequence("Ctrl+-")])
         self.act_zoom_out.triggered.connect(lambda: self._zoom_step_active(-1))
+        self._linux_force_text_action(self.act_zoom_out, "−")   # true minus
 
         self.act_zoom_in = QAction(QIcon.fromTheme("zoom-in"), self.tr("Zoom In"), self)
         self.act_zoom_in.setStatusTip(self.tr("Zoom in"))
-        self.act_zoom_in.setShortcuts([
-            QKeySequence("Ctrl++"),   # Ctrl + (Shift + = on many keyboards)
-            QKeySequence("Ctrl+="),   # fallback
-        ])
+        self.act_zoom_in.setShortcuts([QKeySequence("Ctrl++"), QKeySequence("Ctrl+=")])
         self.act_zoom_in.triggered.connect(lambda: self._zoom_step_active(+1))
+        self._linux_force_text_action(self.act_zoom_in, "+")
 
         self.act_zoom_1_1 = QAction(QIcon.fromTheme("zoom-original"), self.tr("1:1"), self)
         self.act_zoom_1_1.setStatusTip(self.tr("Zoom to 100% (pixel-for-pixel)"))
         self.act_zoom_1_1.setShortcut(QKeySequence("Ctrl+1"))
         self.act_zoom_1_1.triggered.connect(self._zoom_active_1_1)
+        self._linux_force_text_action(self.act_zoom_1_1, "1:1")
 
         self.act_zoom_fit = QAction(QIcon.fromTheme("zoom-fit-best"), self.tr("Fit"), self)
         self.act_zoom_fit.setStatusTip(self.tr("Fit image to current window"))
         self.act_zoom_fit.setShortcut(QKeySequence("Ctrl+0"))
         self.act_zoom_fit.triggered.connect(self._zoom_active_fit)
         self.act_zoom_fit.setCheckable(True)
+        self._linux_force_text_action(self.act_zoom_fit, "Fit")
 
         self.act_auto_fit_resize = QAction(self.tr("Auto-fit on Resize"), self)
         self.act_auto_fit_resize.setCheckable(True)
@@ -813,6 +832,10 @@ class ToolbarMixin:
         self.act_paste_view.setShortcut("Ctrl+Shift+V")
         self.act_copy_view.triggered.connect(self._copy_active_view)
         self.act_paste_view.triggered.connect(self._paste_active_view)
+        # --- Edit: Mono -> RGB (triplicate channels) ---
+        self.act_mono_to_rgb = QAction(self.tr("Convert Mono to RGB"), self)
+        self.act_mono_to_rgb.setStatusTip(self.tr("Convert a mono image to RGB by duplicating the channel"))
+        self.act_mono_to_rgb.triggered.connect(self._convert_mono_to_rgb_active)
 
         # Functions
         self.act_crop = QAction(QIcon(cropicon_path), self.tr("Crop..."), self)
@@ -877,7 +900,7 @@ class ToolbarMixin:
         self.act_linear_fit.setShortcut("Ctrl+L")
         self.act_linear_fit.triggered.connect(self._open_linear_fit)
 
-        self.act_remove_green = QAction(QIcon(green_path), self.tr("Remove Green..."), self)
+        self.act_remove_green = QAction(QIcon(green_path), self.tr("Remove Green (SCNR)..."), self)
         self.act_remove_green.setToolTip(self.tr("SCNR-style green channel removal."))
         self.act_remove_green.setIconVisibleInMenu(True)
         self.act_remove_green.triggered.connect(self._open_remove_green)
@@ -1102,6 +1125,16 @@ class ToolbarMixin:
         self.act_ppp.setStatusTip(self.tr("Pick the perfect palette for your image"))
         self.act_ppp.triggered.connect(self._open_ppp_tool) 
 
+        self.act_narrowband_normalization = QAction(QIcon(narrowbandnormalization_path), self.tr("Narrowband Normalization..."), self)
+        self.act_narrowband_normalization.setStatusTip(
+            self.tr("Normalize HOO/SHO/HSO/HOS (PixelMath port by Bill Blanshan and Mike Cranfield)")
+        )
+        self.act_narrowband_normalization.setIconVisibleInMenu(False)
+        self.act_narrowband_normalization.setShortcut(QKeySequence("Ctrl+Alt+Shift+N"))
+        self.act_narrowband_normalization.setShortcutContext(Qt.ShortcutContext.ApplicationShortcut)
+        self.addAction(self.act_narrowband_normalization)
+        self.act_narrowband_normalization.triggered.connect(self._open_narrowband_normalization_tool)
+
         self.act_nbtorgb = QAction(QIcon(nbtorgb_path), self.tr("NB->RGB Stars..."), self)
         self.act_nbtorgb.setStatusTip(self.tr("Combine narrowband to RGB with optional OSC stars"))
         self.act_nbtorgb.setIconVisibleInMenu(True)
@@ -1149,6 +1182,11 @@ class ToolbarMixin:
         self.act_live_stacking.setStatusTip(self.tr("Live monitor and stack incoming frames"))
         self.act_live_stacking.triggered.connect(self._open_live_stacking)
 
+        self.act_planetary_stacker = QAction(QIcon(planetarystacker_path), self.tr("Planetary Stacker..."), self)
+        self.act_planetary_stacker.setIconVisibleInMenu(True)
+        self.act_planetary_stacker.setStatusTip(self.tr("Stack SER videos (planetary/solar/lunar)"))
+        self.act_planetary_stacker.triggered.connect(self._open_planetary_stacker)
+
         self.act_plate_solve = QAction(QIcon(platesolve_path), self.tr("Plate Solver..."), self)
         self.act_plate_solve.setIconVisibleInMenu(True)
         self.act_plate_solve.setStatusTip(self.tr("Solve WCS/SIP for the active image or a file"))
@@ -1345,6 +1383,7 @@ class ToolbarMixin:
         reg("nbtorgb",       self.act_nbtorgb)
         reg("freqsep",       self.act_freqsep)
         reg("selective_color", self.act_selective_color)
+        reg("narrowband_normalization", self.act_narrowband_normalization)
         reg("contsub",      self.act_contsub)
         reg("abe",          self.act_abe)
         reg("create_mask", self.act_create_mask)
@@ -1369,7 +1408,7 @@ class ToolbarMixin:
         reg("pixel_math", self.act_pixelmath)
         reg("signature_insert", self.act_signature) 
         reg("halo_b_gon", self.act_halobgon)
-
+        reg("planetary_stacker", self.act_planetary_stacker)
         reg("multiscale_decomp", self.act_multiscale_decomp)        
         reg("geom_invert",                 self.act_geom_invert)
         reg("geom_flip_horizontal",        self.act_geom_flip_h)
@@ -1407,6 +1446,83 @@ class ToolbarMixin:
         reg("view_bundles", self.act_view_bundles)
         reg("function_bundles", self.act_function_bundles)
 
+    def _reset_all_toolbars_to_factory(self):
+        """
+        Clears all persisted toolbar membership/order/hidden state so the UI
+        returns to the factory layout defined in code.
+        """
+        if not hasattr(self, "settings"):
+            return
+
+        # 1) Clear global toolbar persistence
+        keys_to_clear = [
+            "Toolbar/Assignments",
+            "Toolbar/HiddenPrev",
+            "Toolbar/HiddenMigrationDone",
+
+            # Per-toolbar order lists
+            "Toolbar/View",
+            "Toolbar/Functions",
+            "Toolbar/Cosmic",
+            "Toolbar/Tools",
+            "Toolbar/Geometry",
+            "Toolbar/StarStuff",
+            "Toolbar/Masks",
+            "Toolbar/WhatsInMy",
+            "Toolbar/Bundles",
+            "Toolbar/Hidden",
+        ]
+
+        for k in keys_to_clear:
+            try:
+                self.settings.remove(k)
+            except Exception:
+                pass
+
+        # 2) Clear legacy hidden lists (old system) if they exist
+        # (These are the ones like "Toolbar/Tools/Hidden")
+        try:
+            # brute-force remove known ones
+            legacy_hidden = [
+                "Toolbar/View/Hidden",
+                "Toolbar/Functions/Hidden",
+                "Toolbar/Cosmic/Hidden",
+                "Toolbar/Tools/Hidden",
+                "Toolbar/Geometry/Hidden",
+                "Toolbar/StarStuff/Hidden",
+                "Toolbar/Masks/Hidden",
+                "Toolbar/WhatsInMy/Hidden",
+                "Toolbar/Bundles/Hidden",
+            ]
+            for k in legacy_hidden:
+                self.settings.remove(k)
+        except Exception:
+            pass
+
+        try:
+            self.settings.sync()
+        except Exception:
+            pass
+
+        # 3) Rebuild toolbars from code defaults
+        # Safest approach: remove existing toolbars and rebuild.
+        from setiastro.saspro.shortcuts import DraggableToolBar
+        for tb in self.findChildren(DraggableToolBar):
+            try:
+                self.removeToolBar(tb)
+                tb.deleteLater()
+            except Exception:
+                pass
+
+        # Build fresh
+        self._init_toolbar()
+
+        # Optional: ensure Hidden stays hidden
+        tb_hidden = self._hidden_toolbar()
+        if tb_hidden:
+            tb_hidden.setVisible(False)
+
+
     def _restore_toolbar_order(self, tb, settings_key: str):
         """
         Restore toolbar action order from QSettings, using command_id/objectName.
@@ -1821,4 +1937,10 @@ class ToolbarMixin:
         if hasattr(self, "act_hide_mask"):
             self.act_hide_mask.setEnabled(has_mask and overlay_on)
 
-
+    def _style_toggle_toolbutton(self, btn: QToolButton):
+        # Make sure the action visually shows "on" state
+        btn.setCheckable(True)  # safe even if already
+        btn.setStyleSheet("""
+            QToolButton { color: #dcdcdc; }
+            QToolButton:checked { color: #DAA520; font-weight: 600; }
+        """)

setiastro/saspro/gui/mixins/update_mixin.py

@@ -10,7 +10,7 @@ import json
 import sys
 import webbrowser
 from typing import TYPE_CHECKING
-
+import re
 from PyQt6.QtCore import QUrl
 from PyQt6.QtNetwork import QNetworkRequest, QNetworkReply
 from PyQt6.QtWidgets import QMessageBox, QApplication
@@ -58,21 +58,20 @@ class UpdateMixin:
         self._ensure_network_manager()
         url_str = self.settings.value("updates/url", self._updates_url, type=str) or self._updates_url
 
-        # ---- TLS availability guard (prevents crash on OpenSSL mismatch) ----
         if url_str.lower().startswith("https://"):
             try:
                 if not QSslSocket.supportsSsl():
-                    msg = "TLS unavailable in Qt (QSslSocket.supportsSsl()=False). Skipping update check."
                     if self.statusBar():
-                        self.statusBar().showMessage(self.tr("Update check unavailable (TLS missing)."), 5000)
+                        self.statusBar().showMessage(self.tr("Update check unavailable (TLS missing)."), 8000)
                     if interactive:
-                        QMessageBox.information(self, self.tr("Update Check"),
-                                                self.tr("Update check is unavailable because TLS is not available on this system."))
+                        QMessageBox.information(
+                            self, self.tr("Update Check"),
+                            self.tr("Update check is unavailable because TLS is not available on this system.")
+                        )
                     else:
-                        print(f"[updates] {msg}")
+                        print("[updates] TLS unavailable in Qt; skipping update check.")
                     return
             except Exception as e:
-                # If QtNetwork is in a weird state, fail safe (do not attempt TLS)
                 print(f"[updates] TLS probe failed ({e}); skipping update check.")
                 return
 
@@ -111,20 +110,22 @@ class UpdateMixin:
     def _on_update_reply(self, reply: QNetworkReply):
         """Handle network reply from update check or download."""
         interactive = bool(reply.property("interactive"))
-        
+
         # Was this the second request (the actual installer download)?
         if bool(reply.property("is_update_download")):
             self._on_windows_update_download_finished(reply)
             return
-        
+
         try:
             if reply.error() != QNetworkReply.NetworkError.NoError:
                 err = reply.errorString()
                 if self.statusBar():
-                    self.statusBar().showMessage("Update check failed.", 5000)
+                    self.statusBar().showMessage(self.tr("Update check failed."), 5000)
                 if interactive:
-                    QMessageBox.warning(self, self.tr("Update Check Failed"),
-                                        self.tr("Unable to check for updates.\n\n{err}").replace("{err}", err))
+                    QMessageBox.warning(
+                        self, self.tr("Update Check Failed"),
+                        self.tr("Unable to check for updates.\n\n{0}").format(err)
+                    )
                 else:
                     print(f"[updates] check failed: {err}")
                 return
@@ -134,12 +135,14 @@ class UpdateMixin:
                 data = json.loads(raw.decode("utf-8"))
             except Exception as je:
                 if self.statusBar():
-                    self.statusBar().showMessage("Update check failed (bad JSON).", 5000)
+                    self.statusBar().showMessage(self.tr("Update check failed (bad JSON)."), 5000)
                 if interactive:
-                    QMessageBox.warning(self, self.tr("Update Check Failed"),
-                                        self.tr("Update JSON is invalid.\n\n{je}").replace("{je}", str(je)))
+                    QMessageBox.warning(
+                        self, self.tr("Update Check Failed"),
+                        self.tr("Update JSON is invalid.\n\n{0}").format(str(je))
+                    )
                 else:
-                    print(f"[updates] bad JSON: {je}")
+                    print(f"[updates] bad JSON: {je!r}")
                 return
 
             latest_str = str(data.get("version", "")).strip()
@@ -148,25 +151,53 @@ class UpdateMixin:
 
             if not latest_str:
                 if self.statusBar():
-                    self.statusBar().showMessage("Update check failed (no 'version').", 5000)
+                    self.statusBar().showMessage(self.tr("Update check failed (no version)."), 5000)
                 if interactive:
-                    QMessageBox.warning(self, self.tr("Update Check Failed"),
-                                        self.tr("Update JSON missing the 'version' field."))
+                    QMessageBox.warning(
+                        self, self.tr("Update Check Failed"),
+                        self.tr("Update JSON missing the 'version' field.")
+                    )
                 else:
                     print("[updates] JSON missing 'version'")
                 return
 
-            cur_tuple = self._parse_version_tuple(self._current_version_str)
-            latest_tuple = self._parse_version_tuple(latest_str)
-            available = bool(latest_tuple and cur_tuple and latest_tuple > cur_tuple)
+            # ---- PEP 440 version compare ----
+            try:
+                from packaging.version import Version
+                cur_v = Version(str(self._current_version_str).strip())
+                latest_v = Version(latest_str)
+            except Exception as e:
+                if self.statusBar():
+                    self.statusBar().showMessage(self.tr("Update check failed (version parse)."), 5000)
+                if interactive:
+                    QMessageBox.warning(
+                        self, self.tr("Update Check Failed"),
+                        self.tr("Could not compare versions.\n\nCurrent: {0}\nLatest: {1}\n\n{2}")
+                            .format(self._current_version_str, latest_str, str(e))
+                    )
+                else:
+                    print(f"[updates] version parse failed: cur={self._current_version_str!r} latest={latest_str!r} err={e!r}")
+                return
+
+            available = latest_v > cur_v
 
             if available:
                 if self.statusBar():
                     self.statusBar().showMessage(self.tr("Update available: {0}").format(latest_str), 5000)
+
                 msg_box = QMessageBox(self)
                 msg_box.setIcon(QMessageBox.Icon.Information)
                 msg_box.setWindowTitle(self.tr("Update Available"))
-                msg_box.setText(self.tr("A new version ({0}) is available!").format(latest_str))
+                installed_norm = str(cur_v)
+                reported_norm  = str(latest_v)
+
+                msg_box.setText(
+                    self.tr(
+                        "An update is available!\n\n"
+                        "Installed version: {0}\n"
+                        "Available version: {1}"
+                    ).format(installed_norm, reported_norm)
+                )
                 if notes:
                     msg_box.setInformativeText(self.tr("Release Notes:\n{0}").format(notes))
                 msg_box.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
@@ -178,27 +209,48 @@ class UpdateMixin:
 
                 if msg_box.exec() == QMessageBox.StandardButton.Yes:
                     plat = sys.platform
-                    link = downloads.get(
+                    key = (
                         "Windows" if plat.startswith("win") else
-                        "macOS" if plat.startswith("darwin") else
-                        "Linux" if plat.startswith("linux") else "", ""
+                        "macOS"   if plat.startswith("darwin") else
+                        "Linux"   if plat.startswith("linux") else
+                        ""
                     )
+                    link = downloads.get(key, "")
                     if not link:
-                        QMessageBox.warning(self, self.tr("Download"), self.tr("No download link available for this platform."))
+                        QMessageBox.warning(self, self.tr("Download"),
+                                            self.tr("No download link available for this platform."))
                         return
 
                     if plat.startswith("win"):
-                        # Use in-app updater for Windows
                         self._start_windows_update_download(link)
                     else:
-                        # Open browser for other platforms
                         webbrowser.open(link)
             else:
                 if self.statusBar():
-                    self.statusBar().showMessage("You're up to date.", 3000)
+                    self.statusBar().showMessage(self.tr("You're up to date."), 3000)
+
                 if interactive:
-                    QMessageBox.information(self, self.tr("Up to Date"),
-                                            self.tr("You're already running the latest version."))
+                    # Use the same parsed versions you already computed
+                    installed_str = str(self._current_version_str).strip()
+                    reported_str  = str(latest_str).strip()
+
+                    # If you have cur_v/latest_v (packaging.Version), use their string forms too
+                    try:
+                        installed_norm = str(cur_v)   # normalized PEP440 (e.g. 1.6.6.post3)
+                        reported_norm  = str(latest_v)
+                    except Exception:
+                        installed_norm = installed_str
+                        reported_norm  = reported_str
+
+                    QMessageBox.information(
+                        self,
+                        self.tr("Up to Date"),
+                        self.tr(
+                            "You're already running the latest version.\n\n"
+                            "Installed version: {0}\n"
+                            "Update source reports: {1}"
+                        ).format(installed_norm, reported_norm)
+                    )
         finally:
             reply.deleteLater()
 
@@ -321,3 +373,39 @@ class UpdateMixin:
 
         # Close app so the installer can overwrite files
         QApplication.instance().quit()
+
+
+    def _normalize_version_str(self, v: str) -> str:
+        v = (v or "").strip()
+        # common cases: "v1.2.3", "Version 1.2.3", "1.2.3 (build xyz)"
+        v = re.sub(r'^[^\d]*', '', v)                # strip leading non-digits
+        v = re.split(r'[\s\(\[]', v, 1)[0].strip()   # stop at whitespace/( or [
+        return v
+
+    def _parse_version(self, v: str):
+        v = self._normalize_version_str(v)
+        if not v:
+            return None
+        # Prefer packaging if present
+        try:
+            from packaging.version import Version
+            return Version(v)
+        except Exception:
+            # Fallback: compare numeric dot parts only
+            parts = re.findall(r'\d+', v)
+            if not parts:
+                return None
+            # normalize length to 3+ (so 1.2 == 1.2.0)
+            nums = [int(x) for x in parts[:6]]
+            while len(nums) < 3:
+                nums.append(0)
+            return tuple(nums)
+
+    def _is_update_available(self, latest_str: str) -> bool:
+        cur = self._parse_version(self._current_version_str)
+        latest = self._parse_version(latest_str)
+        if cur is None or latest is None:
+            # If we cannot compare, do NOT claim "up to date".
+            # Treat as "unknown" and show a failure message in interactive mode.
+            return False
+        return latest > cur