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

setiastro/saspro/gui/mixins/update_mixin.py

@@ -10,11 +10,13 @@ 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
 
+from PyQt6.QtNetwork import QSslSocket
+
 if TYPE_CHECKING:
     pass
 
@@ -44,27 +46,38 @@ class UpdateMixin:
         return str(v or "0.0.0")
 
     def _ensure_network_manager(self):
-        """Ensure the network access manager exists."""
         from PyQt6.QtNetwork import QNetworkAccessManager
-        
-        if not hasattr(self, "_nam") or self._nam is None:
+        if getattr(self, "_nam", None) is None:
             self._nam = QNetworkAccessManager(self)
             self._nam.finished.connect(self._on_update_reply)
 
     def _kick_update_check(self, *, interactive: bool):
         """
         Start an update check request.
-        
-        Args:
-            interactive: If True, show UI feedback for the check
         """
         self._ensure_network_manager()
         url_str = self.settings.value("updates/url", self._updates_url, type=str) or self._updates_url
+
+        if url_str.lower().startswith("https://"):
+            try:
+                if not QSslSocket.supportsSsl():
+                    if self.statusBar():
+                        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.")
+                        )
+                    else:
+                        print("[updates] TLS unavailable in Qt; skipping update check.")
+                    return
+            except Exception as e:
+                print(f"[updates] TLS probe failed ({e}); skipping update check.")
+                return
+
         req = QNetworkRequest(QUrl(url_str))
-        req.setRawHeader(
-            b"User-Agent",
-            f"SASPro/{self._current_version_str}".encode("utf-8")
-        )
+        req.setRawHeader(b"User-Agent", f"SASPro/{self._current_version_str}".encode("utf-8"))
+
         reply = self._nam.get(req)
         reply.setProperty("interactive", interactive)
 
@@ -97,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
@@ -120,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()
@@ -134,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)
@@ -164,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()
 
@@ -307,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

setiastro/saspro/gui/mixins/view_mixin.py

@@ -193,6 +193,7 @@ class ViewMixin:
         if hasattr(view, "set_scale") and callable(view.set_scale):
             try:
                 view.set_scale(float(scale))
+                self._ensure_smooth_resample(view)
                 self._center_view(view)
                 return
             except Exception:
@@ -209,6 +210,47 @@ class ViewMixin:
         except Exception:
             pass
 
+    def _ensure_smooth_resample(self, view):
+        """
+        Make sure the view is using smooth interpolation for the current scale.
+        Different view widgets in SASpro may implement this differently, so we
+        try a few known hooks safely.
+        """
+        # 1) Best case: explicit API
+        for name in ("set_smooth_scaling", "set_interpolation", "set_smooth", "enable_smooth_scaling"):
+            fn = getattr(view, name, None)
+            if callable(fn):
+                try:
+                    fn(True)
+                    return
+                except Exception:
+                    pass
+
+        # 2) Some views store a mode flag
+        for attr in ("smooth_scaling", "_smooth_scaling", "_use_smooth_scaling", "use_smooth_scaling"):
+            if hasattr(view, attr):
+                try:
+                    setattr(view, attr, True)
+                    # kick a repaint/update if available
+                    try:
+                        view.update()
+                    except Exception:
+                        pass
+                    return
+                except Exception:
+                    pass
+
+        # 3) QLabel pixmap scaling: if you have a custom "rebuild pixmap" method, call it
+        for name in ("_rebuild_pixmap", "_update_pixmap", "_render_scaled", "rebuild_pixmap"):
+            fn = getattr(view, name, None)
+            if callable(fn):
+                try:
+                    fn()
+                    return
+                except Exception:
+                    pass
+
+
     def _infer_image_size(self, view):
         """Return (img_w, img_h) in device-independent pixels (ints), best-effort."""
         # Preferred: from the label's pixmap

setiastro/saspro/halobgon.py

@@ -252,6 +252,10 @@ class HaloBGonDialogPro(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        
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e:

setiastro/saspro/histogram.py

@@ -33,13 +33,17 @@ class HistogramDialog(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 = document
         self.image = _to_float_preserve(document.image)
 
         self.zoom_factor = 1.0   # 1.0 = 100%
         self.log_scale   = False # log X
         self.log_y       = False # log Y
-        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
         self._eps_log         = 1e-6      # first log bin edge (for labels)
 
         # for mapping clicks → normalized x

setiastro/saspro/image_combine.py

@@ -94,6 +94,10 @@ class ImageCombineDialog(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.mw = main_window
         self.dm = getattr(main_window, "doc_manager", None) or getattr(main_window, "dm", None)
         self.zoom = 1.0

setiastro/saspro/image_peeker_pro.py

@@ -1317,6 +1317,10 @@ class ImagePeekerDialogPro(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.document = self._coerce_doc(document)   # <- ensure we hold a real doc
         self.settings = settings
         # status / progress line

setiastro/saspro/imageops/starbasedwhitebalance.py

@@ -30,10 +30,10 @@ cached_star_sources: Optional[np.ndarray] = None
 cached_flux_radii: Optional[np.ndarray] = None
 
 
-def _tone_preserve_bg_neutralize(rgb: np.ndarray) -> np.ndarray:
+def _tone_preserve_bg_neutralize(rgb: np.ndarray, *, return_pivot: bool = False):
     """
     Neutralize background using the darkest grid patch in a tone-preserving way.
-    Operates in-place on a copy; returns the neutralized image (float32 [0,1]).
+    Returns float32 RGB in [0,1]. If return_pivot, also returns the patch median (pivot).
     """
     h, w = rgb.shape[:2]
     patch_size = 10
@@ -56,12 +56,15 @@ def _tone_preserve_bg_neutralize(rgb: np.ndarray) -> np.ndarray:
     out = rgb.copy()
     if best is not None:
         avg = float(np.mean(best))
-        # “tone-preserving” shift+scale channel-wise toward avg
         for c in range(3):
             diff = float(best[c] - avg)
             denom = (1.0 - diff) if abs(1.0 - diff) > 1e-8 else 1e-8
             out[:, :, c] = np.clip((out[:, :, c] - diff) / denom, 0.0, 1.0)
-    return out
+
+    if return_pivot:
+        pivot = best.astype(np.float32) if best is not None else np.median(rgb, axis=(0, 1)).astype(np.float32)
+        return out.astype(np.float32, copy=False), pivot
+    return out.astype(np.float32, copy=False)
 
 
 def apply_star_based_white_balance(
@@ -73,38 +76,16 @@ def apply_star_based_white_balance(
 ) -> Tuple[np.ndarray, int, np.ndarray, np.ndarray, np.ndarray] | Tuple[np.ndarray, int, np.ndarray]:
     """
     Star-based white balance with background neutralization and an RGB overlay of detected stars.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        RGB image (any dtype). Assumed RGB ordering.
-    threshold : float
-        SExtractor detection threshold (in background sigma).
-    autostretch : bool
-        If True, overlay is built from an autostretched view for visibility.
-    reuse_cached_sources : bool
-        If True, reuses star positions measured on a previous call (same scene).
-    return_star_colors : bool
-        If True, also returns (raw_star_pixels, after_star_pixels).
-
-    Returns
-    -------
-    balanced_rgb : float32 RGB in [0,1]
-    star_count   : int
-    overlay_rgb  : float32 RGB in [0,1] with star ellipses drawn
-    (optional) raw_star_pixels : (N,3) float array, colors sampled from ORIGINAL image
-    (optional) after_star_pixels : (N,3) float array, colors sampled after WB
+    (Correct version: does NOT crush data below the pivot.)
     """
     if image.ndim != 3 or image.shape[2] != 3:
         raise ValueError("apply_star_based_white_balance: input must be an RGB image (H,W,3).")
 
-    # 0) normalize
     img_rgb = _to_float01(image)
 
-    # 1) first background neutralization (tone-preserving)
-    bg_neutral = _tone_preserve_bg_neutralize(img_rgb)
+    # 1) background neutralization + pivot (per-channel medians of darkest patch)
+    bg_neutral, pivot = _tone_preserve_bg_neutralize(img_rgb, return_pivot=True)
 
-    # 2) detect / reuse star positions
     if sep is None:
         raise ImportError(
             "apply_star_based_white_balance requires the 'sep' package. "
@@ -135,7 +116,6 @@ def apply_star_based_white_balance(
         cached_star_sources = sources
         cached_flux_radii = r
 
-    # filter: small-ish, star-like
     mask = (r > 0) & (r <= 10)
     sources = sources[mask]
     r = r[mask]
@@ -143,15 +123,14 @@ def apply_star_based_white_balance(
         raise ValueError("All detected sources were rejected as non-stellar (too large).")
 
     h, w = gray.shape
-    # raw colors from ORIGINAL image - optimized vectorized extraction
     xs = sources["x"].astype(np.int32)
     ys = sources["y"].astype(np.int32)
     valid = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
+
     raw_star_pixels = img_rgb[ys[valid], xs[valid], :]
 
-    # 3) build overlay (autostretched if requested) and draw ellipses
+    # overlay
     disp = stretch_color_image(bg_neutral.copy(), 0.25) if autostretch else bg_neutral.copy()
-
     if cv2 is not None:
         overlay_bgr = cv2.cvtColor((disp * 255).astype(np.uint8), cv2.COLOR_RGB2BGR)
         for i in range(len(sources)):
@@ -160,41 +139,35 @@ def apply_star_based_white_balance(
             theta_deg = float(sources["theta"][i] * 180.0 / np.pi)
             center = (int(round(cx)), int(round(cy)))
             axes = (max(1, int(round(3 * a))), max(1, int(round(3 * b))))
-            # red ellipse in BGR
             cv2.ellipse(overlay_bgr, center, axes, angle=theta_deg, startAngle=0, endAngle=360,
                         color=(0, 0, 255), thickness=1)
         overlay_rgb = cv2.cvtColor(overlay_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
     else:
-        # fallback: no ellipses, just the display image
         overlay_rgb = disp.astype(np.float32, copy=False)
 
-    # 4) compute WB scale using star colors sampled on bg_neutral image
-    # Optimized: vectorized extraction instead of Python loop (10-50x faster)
-    xs = sources["x"].astype(np.int32)
-    ys = sources["y"].astype(np.int32)
-    valid_mask = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
-    
+    # star pixels for WB
+    valid_mask = valid
     if not np.any(valid_mask):
         raise ValueError("No stellar samples available for white balance.")
-    
+
     star_pixels = bg_neutral[ys[valid_mask], xs[valid_mask], :].astype(np.float32)
     avg_color = np.mean(star_pixels, axis=0)
     max_val = float(np.max(avg_color))
-    # protect against divide-by-zero
     avg_color = np.where(avg_color <= 1e-8, 1e-8, avg_color)
-    scaling = max_val / avg_color
+    scaling = (max_val / avg_color).astype(np.float32)  # (3,)
 
-    balanced = (bg_neutral * scaling.reshape((1, 1, 3))).clip(0.0, 1.0)
+    # ✅ Correct median-locked WB (NO hard floor)
+    m = pivot.reshape((1, 1, 3)).astype(np.float32)
+    g = scaling.reshape((1, 1, 3)).astype(np.float32)
 
-    # 5) second background neutralization pass on balanced image
-    balanced = _tone_preserve_bg_neutralize(balanced)
+    balanced = (bg_neutral.astype(np.float32) - m) * g + m
+    balanced = np.clip(balanced, 0.0, 1.0).astype(np.float32, copy=False)
 
-    # 6) collect after-WB star samples - optimized vectorized extraction
     after_star_pixels = balanced[ys[valid_mask], xs[valid_mask], :]
 
     if return_star_colors:
         return (
-            balanced.astype(np.float32, copy=False),
+            balanced,
             int(len(star_pixels)),
             overlay_rgb.astype(np.float32, copy=False),
             np.asarray(raw_star_pixels, dtype=np.float32),
@@ -202,9 +175,7 @@ def apply_star_based_white_balance(
         )
 
     return (
-        balanced.astype(np.float32, copy=False),
+        balanced,
         int(len(star_pixels)),
         overlay_rgb.astype(np.float32, copy=False),
     )
-
-