setiastrosuitepro 1.8.1.post2__py3-none-any.whl → 1.8.3__py3-none-any.whl

setiastro/saspro/runtime_torch.py

@@ -106,6 +106,26 @@ def _user_runtime_dir(status_cb=print) -> Path:
     _rt_dbg(f"_user_runtime_dir() -> {chosen}", status_cb)
     return chosen
 
+def best_device(torch, *, prefer_cuda=True, prefer_dml=False, prefer_xpu=False):
+    if prefer_cuda and getattr(torch, "cuda", None) and torch.cuda.is_available():
+        return torch.device("cuda")
+
+    # DirectML (Windows)
+    if prefer_dml and platform.system() == "Windows":
+        try:
+            import torch_directml
+            d = torch_directml.device()
+            _ = (torch.ones(1, device=d) + 1).item()
+            return d
+        except Exception:
+            pass
+
+    # MPS
+    if getattr(getattr(torch, "backends", None), "mps", None) and torch.backends.mps.is_available():
+        return torch.device("mps")
+
+    return torch.device("cpu")
+
 
 # ──────────────────────────────────────────────────────────────────────────────
 # Shadowing & sanity checks
@@ -228,31 +248,71 @@ def _pip_ok(venv_python: Path, args: list[str], status_cb=print) -> bool:
 
 def _ensure_numpy(venv_python: Path, status_cb=print) -> None:
     """
-    Torch wheels may not pull NumPy; ensure NumPy is present in the SAME venv.
+    Ensure NumPy exists in the runtime venv AND is ABI-compatible with common
+    torch/vision/audio wheels. In practice: enforce numpy<2.
+
     Safe to call repeatedly.
     """
     def _numpy_present() -> bool:
         code = "import importlib.util; print('OK' if importlib.util.find_spec('numpy') else 'MISS')"
         try:
             out = subprocess.check_output([str(venv_python), "-c", code], text=True).strip()
-            return (out == "OK")
+            return out == "OK"
         except Exception:
             return False
 
-    if _numpy_present():
-        return
+    def _numpy_major() -> int | None:
+        code = (
+            "import numpy as np\n"
+            "v = np.__version__.split('+',1)[0]\n"
+            "print(int(v.split('.',1)[0]))\n"
+        )
+        try:
+            out = subprocess.check_output([str(venv_python), "-c", code], text=True).strip()
+            return int(out)
+        except Exception:
+            return None
 
-    # Keep tools fresh, then install a compatible NumPy (Torch 2.x is fine with NumPy 1.26–2.x)
+    # Keep tools fresh
     _pip_ok(venv_python, ["install", "--upgrade", "pip", "setuptools", "wheel"], status_cb=status_cb)
 
-    # Prefer latest available in [1.26, 3.0)
-    if not _pip_ok(venv_python, ["install", "--prefer-binary", "--no-cache-dir", "numpy>=1.26,<3"], status_cb=status_cb):
-        # Final fallback to a broadly available pin
-        _pip_ok(venv_python, ["install", "--prefer-binary", "--no-cache-dir", "numpy==1.26.*"], status_cb=status_cb)
+    # 1) If NumPy missing → install safe pin
+    if not _numpy_present():
+        status_cb("[RT] Installing NumPy (pinning to numpy<2 for torch wheel compatibility)…")
+        if not _pip_ok(
+            venv_python,
+            ["install", "--prefer-binary", "--no-cache-dir", "numpy<2"],
+            status_cb=status_cb,
+        ):
+            # last-ditch fallback (very widely available)
+            _pip_ok(
+                venv_python,
+                ["install", "--prefer-binary", "--no-cache-dir", "numpy==1.26.*"],
+                status_cb=status_cb,
+            )
 
-    # Post-install verification
+    # 2) If NumPy present but major>=2 → downgrade to numpy<2
+    maj = _numpy_major()
+    if maj is not None and maj >= 2:
+        status_cb("[RT] NumPy 2.x detected in runtime venv; downgrading to numpy<2…")
+        if not _pip_ok(
+            venv_python,
+            ["install", "--prefer-binary", "--no-cache-dir", "--force-reinstall", "numpy<2"],
+            status_cb=status_cb,
+        ):
+            _pip_ok(
+                venv_python,
+                ["install", "--prefer-binary", "--no-cache-dir", "--force-reinstall", "numpy==1.26.*"],
+                status_cb=status_cb,
+            )
+
+    # Post verification
     if not _numpy_present():
         raise RuntimeError("Failed to install NumPy into the SASpro runtime venv.")
+    maj2 = _numpy_major()
+    if maj2 is not None and maj2 >= 2:
+        raise RuntimeError("NumPy is still 2.x in the SASpro runtime venv after pinning; torch stack may not import.")
+
 
 
 def _is_access_denied(exc: BaseException) -> bool:
@@ -1076,6 +1136,7 @@ def import_torch(
                     prefer_dml=prefer_dml,
                     status_cb=status_cb,
                 )
+                _ensure_numpy(vp, status_cb=status_cb)
         except Exception as e:
             if _is_access_denied(e):
                 raise OSError(_access_denied_msg(rt)) from e

setiastro/saspro/sfcc.py

@@ -11,6 +11,8 @@
 
 from __future__ import annotations
 
+from setiastro.saspro.main_helpers import non_blocking_sleep
+
 import os
 import re
 import cv2
@@ -526,7 +528,7 @@ class SFCCDialog(QDialog):
         self.run_spcc_btn.clicked.connect(self.run_spcc)
         row4.addWidget(self.run_spcc_btn)
 
-        self.neutralize_chk = QCheckBox(self.tr("Background Neutralization")); self.neutralize_chk.setChecked(True); row4.addWidget(self.neutralize_chk)
+        self.neutralize_chk = QCheckBox(self.tr("Background Neutralization")); self.neutralize_chk.setChecked(False); row4.addWidget(self.neutralize_chk)
 
         self.run_grad_btn = QPushButton(self.tr("Run Gradient Extraction (Beta)"))
         f3 = self.run_grad_btn.font(); f3.setBold(True); self.run_grad_btn.setFont(f3)
@@ -820,65 +822,6 @@ class SFCCDialog(QDialog):
         idx = self.sens_combo.findText(current_s); self.sens_combo.setCurrentIndex(idx if idx != -1 else 0)
 
     # ── WCS utilities ──────────────────────────────────────────────────
-    def initialize_wcs_from_header(self, header):
-        if header is None:
-            print("No FITS header available; cannot build WCS.")
-            return
-        try:
-            hdr = header.copy()
-
-            # --- normalize deprecated keywords ---
-            if "RADECSYS" in hdr and "RADESYS" not in hdr:
-                radesys_val = str(hdr["RADECSYS"]).strip()
-                hdr["RADESYS"] = radesys_val
-                try:
-                    del hdr["RADECSYS"]
-                except Exception:
-                    pass
-
-                alt_letters = {
-                    k[-1]
-                    for k in hdr.keys()
-                    if re.match(r"^CTYPE[12][A-Z]$", k)
-                }
-                for a in alt_letters:
-                    key = f"RADESYS{a}"
-                    if key not in hdr:
-                        hdr[key] = radesys_val
-
-            if "EPOCH" in hdr and "EQUINOX" not in hdr:
-                hdr["EQUINOX"] = hdr["EPOCH"]
-                try:
-                    del hdr["EPOCH"]
-                except Exception:
-                    pass
-
-            # IMPORTANT: use the normalized hdr, not the original header
-            self.wcs = WCS(hdr, naxis=2, relax=True)
-
-            psm = self.wcs.pixel_scale_matrix
-            self.pixscale = np.hypot(psm[0, 0], psm[1, 0]) * 3600.0
-            self.center_ra, self.center_dec = self.wcs.wcs.crval
-            self.wcs_header = self.wcs.to_header(relax=True)
-
-            # Orientation from normalized header
-            if "CROTA2" in hdr:
-                try:
-                    self.orientation = float(hdr["CROTA2"])
-                except Exception:
-                    self.orientation = None
-            else:
-                self.orientation = self.calculate_orientation(hdr)
-
-            if self.orientation is not None:
-                self.orientation_label.setText(f"Orientation: {self.orientation:.2f}°")
-            else:
-                self.orientation_label.setText("Orientation: N/A")
-
-        except Exception as e:
-            print("WCS initialization error:\n", e)
-
-
     def calculate_orientation(self, header):
         try:
             cd1_1 = float(header.get("CD1_1", 0.0))
@@ -1149,7 +1092,7 @@ class SFCCDialog(QDialog):
                 break
             except Exception:
                 QApplication.processEvents()
-                time.sleep(0.8)
+                non_blocking_sleep(0.8)
 
         if not ok:
             for _ in range(5):
@@ -1159,7 +1102,7 @@ class SFCCDialog(QDialog):
                     break
                 except Exception:
                     QApplication.processEvents()
-                    time.sleep(0.8)
+                    non_blocking_sleep(0.8)
 
         if not ok:
             QMessageBox.critical(self, "SIMBAD Error", "Could not configure SIMBAD votable fields.")
@@ -1178,7 +1121,7 @@ class SFCCDialog(QDialog):
                 break
             except Exception:
                 QApplication.processEvents()
-                time.sleep(1.2)
+                non_blocking_sleep(1.2)
                 result = None
 
         if result is None or len(result) == 0:
@@ -1320,7 +1263,11 @@ class SFCCDialog(QDialog):
         # --- plot / UI feedback (unchanged) ---
         if getattr(self, "figure", None) is not None:
             self.figure.clf()
-
+        doc = self.doc_manager.get_active_document()
+        if doc is not None:
+            meta = dict(doc.metadata or {})
+            meta["SFCC_star_list"] = list(self.star_list)  # keep it JSON-ish
+            self.doc_manager.update_active_document(doc.image, metadata=meta, step_name="SFCC Stars Cached", doc=doc)
         if templates_for_hist:
             uniq, cnt = np.unique(templates_for_hist, return_counts=True)
             types_str = ", ".join([str(u) for u in uniq])
@@ -1440,14 +1387,24 @@ class SFCCDialog(QDialog):
             dy = sources["y"] - star["y"]
             j = int(np.argmin(dx * dx + dy * dy))
             if (dx[j] * dx[j] + dy[j] * dy[j]) < (3.0 ** 2):
-                xi, yi = int(round(float(sources["x"][j]))), int(round(float(sources["y"][j])))
-                if 0 <= xi < W and 0 <= yi < H:
-                    raw_matches.append({
-                        "sim_index": i,
-                        "template": star.get("pickles_match") or star["sp_clean"],
-                        "x_pix": xi,
-                        "y_pix": yi
-                    })
+                x_c = float(sources["x"][j])
+                y_c = float(sources["y"][j])
+
+                raw_matches.append({
+                    "sim_index": i,
+                    "template": star.get("pickles_match") or star["sp_clean"],
+                    "src_index": j,
+
+                    # New canonical centroid keys
+                    "x": x_c,
+                    "y": y_c,
+
+                    # Back-compat keys used elsewhere (gradient step, older code paths)
+                    "x_pix": x_c,
+                    "y_pix": y_c,
+
+                    "a": float(sources["a"][j]),
+                })
 
         if not raw_matches:
             QMessageBox.warning(self, "No Matches", "No SIMBAD star matched to SEP detections.")
@@ -1523,14 +1480,65 @@ class SFCCDialog(QDialog):
             except Exception as e:
                 print(f"[SFCC] Warning: failed to load/integrate template {pname}: {e}")
 
+        def measure_star_rgb_aperture(img_rgb_f32: np.ndarray, x: float, y: float, r: float,
+                                    rin: float, rout: float) -> tuple[float, float, float]:
+            # SEP expects float32, C-contiguous, and (x,y) in pixel coords
+            R = np.ascontiguousarray(img_rgb_f32[..., 0], dtype=np.float32)
+            G = np.ascontiguousarray(img_rgb_f32[..., 1], dtype=np.float32)
+            B = np.ascontiguousarray(img_rgb_f32[..., 2], dtype=np.float32)
+
+            # sum_circle returns (flux, fluxerr, flag) when err not provided; handle either form
+            def _sum(ch):
+                out = sep.sum_circle(ch, np.array([x]), np.array([y]), r,
+                                    subpix=5, bkgann=(rin, rout))
+                # Depending on sep version, out can be (flux, fluxerr, flag) or (flux, flag)
+                if len(out) == 3:
+                    flux, _fluxerr, flag = out
+                else:
+                    flux, flag = out
+                return float(flux[0]), int(flag[0])
+
+            fR, flR = _sum(R)
+            fG, flG = _sum(G)
+            fB, flB = _sum(B)
+
+            # If any flags set, you can reject (edge, etc.)
+            if (flR | flG | flB) != 0:
+                return None, None, None
+
+            return fR, fG, fB
+
+
         # ---- Main match loop (measure from 'base' only) ----
         for m in raw_matches:
-            xi, yi, sp = m["x_pix"], m["y_pix"], m["template"]
+            xi = float(m.get("x_pix", m["x"]))
+            yi = float(m.get("y_pix", m["y"]))
+            sp = m["template"]
 
             # measure on the SEP working copy (already BN’d, only one pedestal handling)
-            Rm = float(base[yi, xi, 0])
-            Gm = float(base[yi, xi, 1])
-            Bm = float(base[yi, xi, 2])
+            x = float(m["x"])
+            y = float(m["y"])
+
+            # Aperture radius choice (simple + robust)
+            # sources["a"] is roughly semi-major sigma-ish from SEP; a common quick rule:
+            # r ~ 2.5 * a, with sane clamps.
+            a = float(m.get("a", 1.5))
+            r = float(np.clip(2.5 * a, 2.0, 12.0))
+
+            # Annulus (your “kicker”): inner/outer in pixels
+            rin  = float(np.clip(3.0 * r, 6.0, 40.0))
+            rout = float(np.clip(5.0 * r, rin + 2.0, 60.0))
+
+            meas = measure_star_rgb_aperture(base, x, y, r, rin, rout)
+            if meas[0] is None:
+                continue
+            Rm, Gm, Bm = meas
+
+            if Gm <= 0:
+                continue
+            meas_RG = Rm / Gm
+            meas_BG = Bm / Gm
+
             if Gm <= 0:
                 continue
 
@@ -1654,7 +1662,8 @@ class SFCCDialog(QDialog):
         QApplication.processEvents()
 
         eps = 1e-8
-        calibrated = base.copy()
+        #calibrated = base.copy()
+        calibrated = img_float.copy() 
 
         R = calibrated[..., 0]
         G = calibrated[..., 1]

setiastro/saspro/stacking_suite.py

@@ -6728,7 +6728,7 @@ class StackingSuiteDialog(QDialog):
                 s = s[:-1]
             try:
                 return float(s)
-            except Exception:
+            except (ValueError, TypeError):
                 return 2.0
         return 2.0
 
@@ -6737,7 +6737,7 @@ class StackingSuiteDialog(QDialog):
     def _set_drizzle_scale(self, r: float | str) -> None:
         if isinstance(r, str):
             try: r = float(r.rstrip("xX"))
-            except: r = 2.0
+            except ValueError: r = 2.0
         r = float(max(1.0, min(3.0, r)))
         # store as “Nx” so the combo’s string stays in sync
         self.settings.setValue("stacking/drizzle_scale", f"{int(r)}x")
@@ -6754,7 +6754,8 @@ class StackingSuiteDialog(QDialog):
         if cb is not None:
             try:
                 return bool(cb.isChecked())
-            except Exception:
+            except (RuntimeError, AttributeError):
+                # Wrapped object might be deleted or invalid
                 pass
         # fallback to settings (headless / older flows)
         return bool(self.settings.value("stacking/drizzle_enabled", False, type=bool))

setiastro/saspro/star_alignment.py

@@ -7172,6 +7172,7 @@ class MosaicMasterDialog(QDialog):
         return None
 
     def poll_submission_status(self, subid):
+        from setiastro.saspro.main_helpers import non_blocking_sleep
         url = ASTROMETRY_API_URL + f"submissions/{subid}"
         for attempt in range(90):  # up to ~15 minutes
             response = robust_api_request("GET", url)
@@ -7180,11 +7181,12 @@ class MosaicMasterDialog(QDialog):
                 if jobs and jobs[0] is not None:
                     return jobs[0]
             print(f"Polling attempt {attempt+1}: Job ID not ready yet.")
-            time.sleep(10)
+            non_blocking_sleep(10)
         QMessageBox.critical(self, "Blind Solve Failed", "Failed to retrieve job ID from Astrometry.net after multiple attempts.")
         return None
 
     def poll_calibration_data(self, job_id):
+        from setiastro.saspro.main_helpers import non_blocking_sleep
         url = ASTROMETRY_API_URL + f"jobs/{job_id}/calibration/"
         for attempt in range(90):
             response = robust_api_request("GET", url)
@@ -7192,7 +7194,7 @@ class MosaicMasterDialog(QDialog):
                 print("Calibration data retrieved:", response)
                 return response
             print(f"Calibration data not available yet (attempt {attempt+1})")
-            time.sleep(10)
+            non_blocking_sleep(10)
         QMessageBox.critical(self, "Blind Solve Failed", "Calibration data did not complete in the expected timeframe.")
         return None
 

setiastro/saspro/texture_clarity.py

@@ -154,7 +154,7 @@ def _apply_clarity(image: np.ndarray, amount: float, radius: float) -> np.ndarra
             print(f"Bilateral Filter failed: {e}")
             try:
                 base = cv2.GaussianBlur(img_f32, (0, 0), sigma_space_target)
-            except:
+            except Exception:
                 return image
     else:
         return image

setiastro/saspro/torch_rejection.py

@@ -5,7 +5,7 @@ import numpy as np
 
 # Always route through our runtime shim so ALL GPU users share the same backend.
 # Nothing heavy happens at import; we only resolve Torch when needed.
-from .runtime_torch import import_torch, add_runtime_to_sys_path
+from .runtime_torch import import_torch, add_runtime_to_sys_path, best_device
 
 # Algorithms supported by the GPU path here (names match your UI/CPU counterparts)
 _SUPPORTED = {
@@ -31,47 +31,37 @@ _SUPPORTED = {
 _TORCH = None
 _DEVICE = None
 
-def _get_torch(prefer_cuda: bool = True):
-    """
-    Resolve and cache the torch module via the SAS runtime shim.
-    This may install/repair torch into the per-user runtime if needed.
-    """
+
+
+def _get_torch(prefer_cuda: bool = True, prefer_dml: bool = False):
     global _TORCH, _DEVICE
     if _TORCH is not None:
         return _TORCH
 
-    # In frozen builds, help the process see the runtime site-packages first.
     try:
         add_runtime_to_sys_path(lambda *_: None)
     except Exception:
         pass
 
-    # Import (and if necessary, install) torch using the unified runtime.
-    torch = import_torch(prefer_cuda=prefer_cuda, status_cb=lambda *_: None)
+    # Let runtime_torch install the right stack
+    torch = import_torch(prefer_cuda=prefer_cuda, prefer_dml=prefer_dml, status_cb=lambda *_: None)
+    _DEVICE = best_device(torch, prefer_cuda=True, prefer_dml=prefer_dml)
     _TORCH = torch
     _force_fp32_policy(torch)
 
-    # Choose the best device once; cheap calls, but cached anyway
-    try:
-        if hasattr(torch, "cuda") and torch.cuda.is_available():
-            _DEVICE = torch.device("cuda")
-        elif getattr(getattr(torch, "backends", None), "mps", None) and torch.backends.mps.is_available():
-            _DEVICE = torch.device("mps")
-        else:
-            # Try DirectML for AMD/Intel GPUs on Windows
-            try:
-                import torch_directml
-                dml_device = torch_directml.device()
-                # Quick sanity check
-                _ = (torch.ones(1, device=dml_device) + 1).item()
-                _DEVICE = dml_device
-            except Exception:
-                _DEVICE = torch.device("cpu")
-    except Exception:
+    # Device selection: CUDA first, else CPU.
+    # (If runtime_torch installed DML, then your app should choose DML device elsewhere
+    #  OR you add a runtime_torch helper to return it.)
+    if hasattr(torch, "cuda") and torch.cuda.is_available():
+        _DEVICE = torch.device("cuda")
+    elif getattr(getattr(torch, "backends", None), "mps", None) and torch.backends.mps.is_available():
+        _DEVICE = torch.device("mps")
+    else:
         _DEVICE = torch.device("cpu")
 
     return _TORCH
 
+
 def _device():
     if _DEVICE is not None:
         return _DEVICE
@@ -246,11 +236,52 @@ def torch_reduce_tile(
     ts = torch.from_numpy(ts_np).to(dev, dtype=torch.float32, non_blocking=True)
 
     # Weights broadcast to 4D
+    # Weights -> broadcastable 4D tensor (F,1,1,1) or (F,1,1,C) or (F,H,W,1) or (F,H,W,C)
     weights_np = np.asarray(weights_np, dtype=np.float32)
+
+    if weights_np.ndim == 0:
+        # scalar -> per-frame scalar (rare)
+        weights_np = np.full((F,), float(weights_np), dtype=np.float32)
+
     if weights_np.ndim == 1:
-        w = torch.from_numpy(weights_np).to(dev, dtype=torch.float32, non_blocking=True).view(F,1,1,1)
+        if weights_np.shape[0] != F:
+            raise ValueError(f"weights shape {weights_np.shape} does not match F={F}")
+        w_np = weights_np.reshape(F, 1, 1, 1)
+
+    elif weights_np.ndim == 2:
+        # Most important fix: (F,C) per-channel weights
+        if weights_np.shape == (F, C):
+            w_np = weights_np.reshape(F, 1, 1, C)
+        # Sometimes people accidentally pass (F,H) or (F,W) -> reject loudly
+        else:
+            raise ValueError(
+                f"Unsupported 2D weights shape {weights_np.shape}. "
+                f"Expected (F,C)=({F},{C}) for per-channel weights."
+            )
+
+    elif weights_np.ndim == 3:
+        # (F,H,W) -> treat as single-channel weight map
+        if weights_np.shape == (F, H, W):
+            w_np = weights_np[..., None]  # (F,H,W,1)
+        else:
+            raise ValueError(
+                f"Unsupported 3D weights shape {weights_np.shape}. Expected (F,H,W)=({F},{H},{W})."
+            )
+
+    elif weights_np.ndim == 4:
+        if weights_np.shape == (F, H, W, 1) or weights_np.shape == (F, H, W, C):
+            w_np = weights_np
+        else:
+            raise ValueError(
+                f"Unsupported 4D weights shape {weights_np.shape}. "
+                f"Expected (F,H,W,1) or (F,H,W,C)=({F},{H},{W},{C})."
+            )
     else:
-        w = torch.from_numpy(weights_np).to(dev, dtype=torch.float32, non_blocking=True)
+        raise ValueError(f"Unsupported weights ndim={weights_np.ndim} shape={weights_np.shape}")
+
+    # Host -> device
+    w = torch.from_numpy(w_np).to(dev, dtype=torch.float32, non_blocking=False)
+
 
     algo = algo_name
     valid = torch.isfinite(ts)

setiastro/saspro/widgets/image_utils.py

@@ -66,7 +66,9 @@ def numpy_to_qimage(arr: np.ndarray, normalize: bool = True) -> QImage:
     if arr.ndim == 2:
         # Grayscale
         h, w = arr.shape
-        return QImage(arr.data, w, h, w, QImage.Format.Format_Grayscale8).copy()
+        img = QImage(arr.data, w, h, w, QImage.Format.Format_Grayscale8)
+        img._buf = arr # Keep alive
+        return img
     
     elif arr.ndim == 3:
         h, w, c = arr.shape
@@ -74,17 +76,23 @@ def numpy_to_qimage(arr: np.ndarray, normalize: bool = True) -> QImage:
         if c == 1:
             # Grayscale with channel dim
             arr = arr.squeeze()
-            return QImage(arr.data, w, h, w, QImage.Format.Format_Grayscale8).copy()
+            img = QImage(arr.data, w, h, w, QImage.Format.Format_Grayscale8)
+            img._buf = arr
+            return img
         
         elif c == 3:
             # RGB
             bytes_per_line = 3 * w
-            return QImage(arr.data, w, h, bytes_per_line, QImage.Format.Format_RGB888).copy()
+            img = QImage(arr.data, w, h, bytes_per_line, QImage.Format.Format_RGB888)
+            img._buf = arr
+            return img
         
         elif c == 4:
             # RGBA
             bytes_per_line = 4 * w
-            return QImage(arr.data, w, h, bytes_per_line, QImage.Format.Format_RGBA8888).copy()
+            img = QImage(arr.data, w, h, bytes_per_line, QImage.Format.Format_RGBA8888)
+            img._buf = arr
+            return img
         
         else:
             raise ValueError(f"Unsupported number of channels: {c}")

setiastro/saspro/wimi.py

@@ -28,6 +28,7 @@ import lz4.block
 import zstandard
 import base64
 import ast
+from setiastro.saspro.main_helpers import non_blocking_sleep
 import platform
 from pathlib import Path
 import glob
@@ -6789,7 +6790,7 @@ class WIMIDialog(QDialog):
             except Exception as e:
                 last_err = e
                 if attempt < 4:
-                    time.sleep(1)  # or QThread.msleep(1000) if you want less UI freeze
+                    non_blocking_sleep(1)
                 else:
                     # After 5 attempts total, stop with a helpful message
                     err_txt = str(last_err) if last_err is not None else "Unknown error"

setiastro/saspro/xisf.py

@@ -1072,7 +1072,7 @@ class XISF:
         }
         try:
             return _dtypes[s]
-        except:
+        except KeyError:
             raise NotImplementedError(f"sampleFormat {s} not implemented")
 
     # Return XISF data type from numpy dtype
@@ -1087,7 +1087,7 @@ class XISF:
         }
         try:
             return _sampleFormats[str(dtype)]
-        except:
+        except KeyError:
             raise NotImplementedError(f"sampleFormat for {dtype} not implemented")
 
     @staticmethod
@@ -1121,7 +1121,7 @@ class XISF:
         }
         try:
             return _dtypes[type_prefix]
-        except:
+        except KeyError:
             raise NotImplementedError(f"data type {type_name} not implemented")
 
     # __/ Auxiliary functions for compression/shuffling \________

{setiastrosuitepro-1.8.1.post2.dist-info → setiastrosuitepro-1.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setiastrosuitepro
-Version: 1.8.1.post2
+Version: 1.8.3
 Summary: Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization
 License: GPL-3.0
 License-File: LICENSE
@@ -68,9 +68,9 @@ Description-Content-Type: text/markdown
 
 ### Other contributors:
 - [Fabio Tempera](https://github.com/Ft2801) 🥇
-  - Complete code refactoring of `setiastrosuitepro.py` (20,000+ lines), and duplicated code removal across the project
-  - Addition of AstroSpikes tool, secret minigame, system resources monitor, app statistics, and 10+ language translations
-  - Implementation of UI elements, startup window, caching methods, lazy imports, utils functions, better memory management, and other important code optimizations across the entire project
+  - Complete code refactoring of `setiastrosuitepro.py` (20,000+ lines), and duplicated code removal across the entire project
+  - Addition of AstroSpikes tool, Texture and Clarity, secret minigame, system resources monitor, app statistics, and 10+ language translations
+  - Implementation of UI elements, startup optimizations, startup window, caching methods, lazy imports, utils functions, better memory management, and other important code optimizations across the entire project
 - [Joaquin Rodriguez](https://github.com/jrhuerta)
   - Project migration to Poetry
 - [Tim Dicke](https://github.com/dickett)