setiastrosuitepro 1.8.0.post3__py3-none-any.whl → 1.8.2__py3-none-any.whl

setiastro/saspro/gui/main_window.py

@@ -33,8 +33,8 @@ from urllib.parse import quote, quote_plus
 # ============================================================================
 import numpy as np
 import matplotlib
-from tifffile import imwrite
-from setiastro.saspro.xisf import XISF
+# tifffile and XISF imports removed (unused in this file)
+
 
 # ============================================================================
 # Bootstrap Configuration (must run early)
@@ -93,18 +93,8 @@ from setiastro.saspro.widgets.common_utilities import (
 )
 
 
-# Reproject for WCS-based alignment
-try:
-    from reproject import reproject_interp
-except ImportError:
-    reproject_interp = None  # fallback if not installed
+# Reproject and OpenCV imports removed (unused or available via lazy_imports)
 
-# OpenCV for transform estimation & warping
-try:
-    import cv2
-    OPENCV_AVAILABLE = True
-except ImportError:
-    OPENCV_AVAILABLE = False
 
 
 
@@ -196,7 +186,7 @@ from setiastro.saspro.resources import (
     colorwheel_path, font_path, csv_icon_path, spinner_path, wims_path, narrowbandnormalization_path,
     wimi_path, linearfit_path, debayer_path, aberration_path, acv_icon_path,
     functionbundles_path, viewbundles_path, selectivecolor_path, rgbalign_path, planetarystacker_path,
-    background_path, script_icon_path, planetprojection_path,clonestampicon_path,
+    background_path, script_icon_path, planetprojection_path,clonestampicon_path, finderchart_path,
 )
 
 import faulthandler
@@ -4238,6 +4228,38 @@ class AstroSuiteProMainWindow(
         except Exception:
             pass
 
+    def _doc_has_wcs(self, doc) -> bool:
+        if doc is None:
+            return False
+        meta = getattr(doc, "metadata", None) or {}
+        if meta.get("wcs") is not None:
+            return True
+
+        hdr = meta.get("original_header") or meta.get("fits_header") or meta.get("header")
+        if hdr is None:
+            return False
+
+        try:
+            keys = {str(k).upper() for k in hdr.keys()}
+        except Exception:
+            try:
+                keys = {str(k).upper() for k in dict(hdr).keys()}
+            except Exception:
+                return False
+
+        return {"CTYPE1","CTYPE2","CRVAL1","CRVAL2"}.issubset(keys)
+
+
+    def _open_finder_chart(self):
+        doc = self._active_doc()
+        if not self._doc_has_wcs(doc):
+            QMessageBox.information(self, self.tr("Finder Chart"), self.tr("Active image has no astrometric solution (WCS). Plate solve first."))
+            return
+
+        from setiastro.saspro.finder_chart import FinderChartDialog
+        dlg = FinderChartDialog(doc=doc, settings=self.settings, parent=self)
+        dlg.setWindowIcon(QIcon(finderchart_path))
+        dlg.show()
 
     def _open_stellar_alignment(self):
         from setiastro.saspro.star_alignment import StellarAlignmentDialog

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -204,6 +204,7 @@ class MenuMixin:
 
         m_star.addAction(self.act_astrospike)
         m_star.addAction(self.act_exo_detector)
+
         m_star.addAction(self.act_image_peeker)
         m_star.addAction(self.act_isophote)
         m_star.addAction(self.act_live_stacking)
@@ -233,6 +234,7 @@ class MenuMixin:
         m_wim = mb.addMenu(self.tr("&What's In My..."))
         m_wim.addAction(self.act_whats_in_my_sky)
         m_wim.addAction(self.act_wimi)
+        m_wim.addAction(self.act_finder_chart) 
 
         m_scripts = mb.addMenu(self.tr("&Scripts"))
         self.menu_scripts = m_scripts

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -36,7 +36,7 @@ from setiastro.saspro.resources import (
     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, planetarystacker_path,
-    selectivecolor_path, rgbalign_path, planetprojection_path, clonestampicon_path,
+    selectivecolor_path, rgbalign_path, planetprojection_path, clonestampicon_path, finderchart_path,
 )
 
 # Import shortcuts module
@@ -298,6 +298,7 @@ class ToolbarMixin:
         tb_star.addAction(self.act_planetary_stacker)
         tb_star.addAction(self.act_planet_projection)
         tb_star.addAction(self.act_plate_solve)
+        
         tb_star.addAction(self.act_star_align)
         tb_star.addAction(self.act_star_register)
         tb_star.addAction(self.act_rgb_align)
@@ -332,6 +333,7 @@ class ToolbarMixin:
         tb_wim = DraggableToolBar(self.tr("What's In My..."), self)
         tb_wim.setObjectName("What's In My...")
         tb_wim.setSettingsKey("Toolbar/WhatsInMy")
+        tb_wim.addAction(self.act_finder_chart)
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_wim)
 
         tb_wim.addAction(self.act_whats_in_my_sky)
@@ -1245,6 +1247,11 @@ class ToolbarMixin:
         self.act_rgb_align.setStatusTip(self.tr("Align R and B channels to G using astroalign (affine/homography/poly)"))
         self.act_rgb_align.triggered.connect(self._open_rgb_align)
 
+        self.act_finder_chart = QAction(QIcon(finderchart_path), self.tr("Finder Chart..."), self)
+        self.act_finder_chart.setIconVisibleInMenu(True)
+        self.act_finder_chart.setStatusTip(self.tr("Show a finder chart for the active plate-solved image"))
+        self.act_finder_chart.triggered.connect(self._open_finder_chart)
+
         self.act_whats_in_my_sky = QAction(QIcon(wims_path), self.tr("What's In My Sky..."), self)
         self.act_whats_in_my_sky.setIconVisibleInMenu(True)
         self.act_whats_in_my_sky.setStatusTip(self.tr("Plan targets by altitude, transit time, and lunar separation"))
@@ -1446,6 +1453,7 @@ class ToolbarMixin:
         reg("astrospike", self.act_astrospike)
         reg("exo_detector", self.act_exo_detector)
         reg("isophote", self.act_isophote) 
+        reg("finder_chart", self.act_finder_chart)
         reg("rgb_align", self.act_rgb_align) 
         reg("whats_in_my_sky", self.act_whats_in_my_sky)
         reg("whats_in_my_image", self.act_wimi)

setiastro/saspro/legacy/image_manager.py

@@ -242,8 +242,16 @@ class ImageManager(QObject):
     def set_image(self, new_image, metadata, step_name=None):
         slot = self.current_slot
         if self._images[slot] is not None:
+            # OPTIMIZATION: If we are setting the EXACT SAME image object (e.g. metadata update),
+            # do not deep-copy the image data to undo stack.
+            # This saves massive memory when just renaming a slot or changing WCS.
+            if new_image is self._images[slot]:
+                 stored_img = self._images[slot] # Shallow copy / reference
+            else:
+                 stored_img = self._images[slot].copy() # Deep copy for safety
+
             self._undo_stacks[slot].append(
-                (self._images[slot].copy(), self._metadata[slot].copy(), step_name or "Unnamed Step")
+                (stored_img, self._metadata[slot].copy(), step_name or "Unnamed Step")
             )
             self._redo_stacks[slot].clear()
             print(f"ImageManager: Previous image in slot {slot} pushed to undo stack.")
@@ -1526,8 +1534,12 @@ def load_image(filename, max_retries=3, wait_seconds=3, return_metadata: bool =
                 # 1) PixInsight astrometric solution (fallback only)
                 try:
                     if not all(k in hdr for k in ("CRPIX1","CRPIX2","CRVAL1","CRVAL2")):
-                        ref_img = props['PCL:AstrometricSolution:ReferenceImageCoordinates']['value']
-                        ref_sky = props['PCL:AstrometricSolution:ReferenceCelestialCoordinates']['value']
+                        p_img = props['PCL:AstrometricSolution:ReferenceImageCoordinates']
+                        p_sky = props['PCL:AstrometricSolution:ReferenceCelestialCoordinates']
+                        
+                        # Resolve lazy properties (decode base64/binary)
+                        ref_img = xisf.resolve_property(p_img)
+                        ref_sky = xisf.resolve_property(p_sky)
 
                         # Some files store extra values; only first two are CRPIX/CRVAL
                         im0, im1 = float(ref_img[0]), float(ref_img[1])
@@ -1547,7 +1559,9 @@ def load_image(filename, max_retries=3, wait_seconds=3, return_metadata: bool =
                 # 2) CD matrix (fallback only)
                 try:
                     if not all(k in hdr for k in ("CD1_1","CD1_2","CD2_1","CD2_2")):
-                        lin = np.asarray(props['PCL:AstrometricSolution:LinearTransformationMatrix']['value'], float)
+                        p_mat = props['PCL:AstrometricSolution:LinearTransformationMatrix']
+                        lin = np.asarray(xisf.resolve_property(p_mat), float)
+                        
                         hdr['CD1_1'], hdr['CD1_2'] = float(lin[0,0]), float(lin[0,1])
                         hdr['CD2_1'], hdr['CD2_2'] = float(lin[1,0]), float(lin[1,1])
                         _filled |= {'CD1_1','CD1_2','CD2_1','CD2_2'}

setiastro/saspro/legacy/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 \________

setiastro/saspro/main_helpers.py

@@ -1,3 +1,4 @@
+
 # pro/main_helpers.py
 """
 Helper functions extracted from the main module.
@@ -7,12 +8,15 @@ Contains utility functions used throughout the main window:
 - Document name/type detection
 - Widget safety checks
 - WCS/FITS header utilities
+- UI responsiveness helpers
 """
 
 import os
+import time
 from typing import Optional, Tuple
 
 from PyQt6 import sip
+from PyQt6.QtWidgets import QApplication
 
 from setiastro.saspro.file_utils import (
     _normalize_ext,
@@ -23,6 +27,20 @@ from setiastro.saspro.file_utils import (
 )
 
 
+def non_blocking_sleep(duration_sec: float):
+    """
+    Sleep for duration_sec seconds while keeping the UI responsive.
+    Uses QApplication.processEvents() to process pending events.
+    """
+    end_time = time.time() + duration_sec
+    while time.time() < end_time:
+        QApplication.processEvents()
+        # Sleep a tiny bit to avoid 100% CPU usage
+        sleep_time = min(0.05, end_time - time.time())
+        if sleep_time > 0:
+            time.sleep(sleep_time)
+
+
 def safe_join_dir_and_name(directory: str, basename: str) -> str:
     """
     Join directory + sanitized basename. 

setiastro/saspro/memory_utils.py

@@ -128,30 +128,34 @@ class LRUDict(OrderedDict):
     When maxsize is exceeded, oldest items are evicted.
     Thread-safe for basic operations.
     """
-    __slots__ = ('maxsize',)
+    __slots__ = ('maxsize', '_lock')
     
     def __init__(self, maxsize: int = 500):
         super().__init__()
         self.maxsize = maxsize
+        self._lock = threading.RLock()
     
     def __getitem__(self, key):
-        # Move to end on access (most recently used)
-        self.move_to_end(key)
-        return super().__getitem__(key)
-    
-    def get(self, key, default=None):
-        if key in self:
+        with self._lock:
+            # Move to end on access (most recently used)
             self.move_to_end(key)
             return super().__getitem__(key)
-        return default
+    
+    def get(self, key, default=None):
+        with self._lock:
+            if key in self:
+                self.move_to_end(key)
+                return super().__getitem__(key)
+            return default
     
     def __setitem__(self, key, value):
-        if key in self:
-            self.move_to_end(key)
-        super().__setitem__(key, value)
-        # Evict oldest if over limit
-        while len(self) > self.maxsize:
-            self.popitem(last=False)  # Remove oldest
+        with self._lock:
+            if key in self:
+                self.move_to_end(key)
+            super().__setitem__(key, value)
+            # Evict oldest if over limit
+            while len(self) > self.maxsize:
+                self.popitem(last=False)  # Remove oldest
 
 
 # ============================================================================

setiastro/saspro/model_manager.py

@@ -131,6 +131,71 @@ def _parse_gdrive_download_form(html: str) -> tuple[Optional[str], Optional[dict
 
     return action, params
 
+def download_http_file(
+    url: str,
+    dst_path: str | os.PathLike,
+    *,
+    progress_cb: ProgressCB = None,
+    should_cancel=None,
+    timeout: int = 60,
+    chunk_size: int = 1024 * 1024,
+) -> Path:
+    import requests
+
+    dst = Path(dst_path)
+    tmp = dst.with_suffix(dst.suffix + ".part")
+    tmp.parent.mkdir(parents=True, exist_ok=True)
+
+    def log(msg: str):
+        if progress_cb:
+            progress_cb(msg)
+
+    try:
+        tmp.unlink(missing_ok=True)
+    except Exception:
+        pass
+
+    with requests.Session() as s:
+        log(f"Connecting… {url}")
+        r = s.get(url, stream=True, timeout=timeout, allow_redirects=True)
+        r.raise_for_status()
+
+        total = int(r.headers.get("Content-Length") or 0)
+        done = 0
+        t_last = time.time()
+        done_last = 0
+
+        with open(tmp, "wb") as f:
+            for chunk in r.iter_content(chunk_size=chunk_size):
+                if should_cancel and should_cancel():
+                    try:
+                        f.close()
+                        tmp.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+                    raise RuntimeError("Download canceled.")
+
+                if not chunk:
+                    continue
+
+                f.write(chunk)
+                done += len(chunk)
+
+                now = time.time()
+                if now - t_last >= 0.5:
+                    if total > 0:
+                        pct = (done * 100.0) / total
+                        log(f"Downloading… {pct:5.1f}% ({done}/{total} bytes)")
+                    else:
+                        bps = (done - done_last) / max(now - t_last, 1e-9)
+                        log(f"Downloading… {done} bytes ({bps/1024/1024:.1f} MB/s)")
+                    t_last = now
+                    done_last = done
+
+    os.replace(str(tmp), str(dst))
+    log(f"Download complete: {dst}")
+    return dst
+
 
 def download_google_drive_file(
     file_id: str,

setiastro/saspro/model_workers.py

@@ -9,6 +9,7 @@ import zipfile
 from setiastro.saspro.model_manager import (
     extract_drive_file_id,
     download_google_drive_file,
+    download_http_file,
     install_models_zip,
     sha256_file,
 )
@@ -54,49 +55,82 @@ class ModelsDownloadWorker(QObject):
     progress = pyqtSignal(str)
     finished = pyqtSignal(bool, str)
 
-    def __init__(self, primary: str, backup: str, expected_sha256: str | None = None, should_cancel=None):
+    def __init__(self, primary: str, backup: str, tertiary: str | None = None,
+                 expected_sha256: str | None = None, should_cancel=None):
         super().__init__()
         self.primary = primary
         self.backup = backup
+        self.tertiary = (tertiary or "").strip() or None
         self.expected_sha256 = (expected_sha256 or "").strip() or None
         self.should_cancel = should_cancel  # callable -> bool
 
     def run(self):
         try:
-            # The inputs should be FILE links (or IDs), not folder links.
-            fid = extract_drive_file_id(self.primary) or extract_drive_file_id(self.backup)
-            if not fid:
-                raise RuntimeError(
-                    "Models URL is not a Google Drive *file* link or id.\n"
-                    "Please provide a shared file link (…/file/d/<ID>/view) to the models zip."
-                )
-
             tmp = os.path.join(tempfile.gettempdir(), "saspro_models_latest.zip")
-            try:
-                self.progress.emit("Downloading from primary…")
-                download_google_drive_file(fid, tmp, progress_cb=lambda s: self.progress.emit(s), should_cancel=self.should_cancel)
-            except Exception as e:
-                # Try backup if primary fails AND backup has a different file id
-                fid2 = extract_drive_file_id(self.backup)
-                if fid2 and fid2 != fid:
-                    self.progress.emit("Primary failed. Trying backup…")
-                    download_google_drive_file(fid2, tmp, progress_cb=lambda s: self.progress.emit(s), should_cancel=self.should_cancel)
-                else:
-                    raise
 
+            # 1) Try Google Drive primary/backup (by file id)
+            fid_primary = extract_drive_file_id(self.primary)
+            fid_backup  = extract_drive_file_id(self.backup)
+
+            drive_ok = False
+            used_source = None
+
+            if fid_primary or fid_backup:
+                try:
+                    if fid_primary:
+                        self.progress.emit("Downloading from primary (Google Drive)…")
+                        download_google_drive_file(
+                            fid_primary, tmp,
+                            progress_cb=lambda s: self.progress.emit(s),
+                            should_cancel=self.should_cancel
+                        )
+                        drive_ok = True
+                        used_source = ("google_drive", fid_primary)
+                    else:
+                        raise RuntimeError("Primary is not a valid Drive file link/id.")
+                except Exception:
+                    # Try backup if different id
+                    if fid_backup and fid_backup != fid_primary:
+                        self.progress.emit("Primary failed. Trying backup (Google Drive)…")
+                        download_google_drive_file(
+                            fid_backup, tmp,
+                            progress_cb=lambda s: self.progress.emit(s),
+                            should_cancel=self.should_cancel
+                        )
+                        drive_ok = True
+                        used_source = ("google_drive", fid_backup)
+
+            # 2) If Drive failed (or links weren’t Drive), try GitHub / HTTP tertiary
+            if not drive_ok:
+                if not self.tertiary:
+                    raise RuntimeError(
+                        "Google Drive download failed and no tertiary mirror URL was provided."
+                    )
+                self.progress.emit("Google Drive failed. Trying GitHub mirror…")
+                download_http_file(
+                    self.tertiary, tmp,
+                    progress_cb=lambda s: self.progress.emit(s),
+                    should_cancel=self.should_cancel
+                )
+                used_source = ("http", self.tertiary)
+
+            # 3) Optional checksum
             if self.expected_sha256:
                 self.progress.emit("Verifying checksum…")
                 got = sha256_file(tmp)
                 if got.lower() != self.expected_sha256.lower():
                     raise RuntimeError(f"SHA256 mismatch.\nExpected: {self.expected_sha256}\nGot:      {got}")
 
+            # 4) Install + manifest
+            src_kind, src_val = used_source if used_source else ("unknown", "")
             manifest = {
-                "source": "google_drive",
-                "file_id": fid,
-                "sha256": self.expected_sha256,
+                "source": src_kind,
+                "source_ref": src_val,
+                "sha256": self.expected_sha256 or "",
             }
-            install_models_zip(tmp, progress_cb=lambda s: self.progress.emit(s), manifest=manifest)
 
+            install_models_zip(tmp, progress_cb=lambda s: self.progress.emit(s), manifest=manifest)
             self.finished.emit(True, "Models updated successfully.")
         except Exception as e:
             self.finished.emit(False, str(e))
+

setiastro/saspro/ops/settings.py

@@ -248,7 +248,8 @@ class SettingsDialog(QDialog):
         self.btn_models_install_zip.clicked.connect(self._models_install_from_zip_clicked)
 
         self.btn_models_open_drive = QPushButton(self.tr("Open Drive…"))
-        self.btn_models_open_drive.setToolTip(self.tr("Open the models folder in your browser (Primary/Backup)"))
+        self.btn_models_open_drive.setToolTip(self.tr("Download models (Primary/Backup/GitHub mirror)"))
+
         self.btn_models_open_drive.clicked.connect(self._models_open_drive_clicked)
 
         row_models = QHBoxLayout()
@@ -319,16 +320,22 @@ class SettingsDialog(QDialog):
     def _models_open_drive_clicked(self):
         PRIMARY_FOLDER = "https://drive.google.com/drive/folders/1-fktZb3I9l-mQimJX2fZAmJCBj_t0yAF?usp=drive_link"
         BACKUP_FOLDER  = "https://drive.google.com/drive/folders/1j46RV6touQtOmtxkhdFWGm_LQKwEpTl9?usp=drive_link"
+        GITHUB_ZIP     = "https://github.com/setiastro/setiastrosuitepro/releases/download/benchmarkFIT/SASPro_Models_Latest.zip"
 
         menu = QMenu(self)
-        act_primary = menu.addAction(self.tr("Primary"))
-        act_backup  = menu.addAction(self.tr("Backup"))
+        act_primary = menu.addAction(self.tr("Primary (Google Drive)"))
+        act_backup  = menu.addAction(self.tr("Backup (Google Drive)"))
+        menu.addSeparator()
+        act_gh      = menu.addAction(self.tr("GitHub (no quota limit)"))
 
         chosen = menu.exec(self.btn_models_open_drive.mapToGlobal(self.btn_models_open_drive.rect().bottomLeft()))
         if chosen == act_primary:
             webbrowser.open(PRIMARY_FOLDER)
         elif chosen == act_backup:
             webbrowser.open(BACKUP_FOLDER)
+        elif chosen == act_gh:
+            webbrowser.open(GITHUB_ZIP)
+
 
 
     def _models_install_from_zip_clicked(self):
@@ -404,6 +411,7 @@ class SettingsDialog(QDialog):
         # Put your actual *zip file* share links here once you create them.
         PRIMARY = "https://drive.google.com/file/d/1n4p0grtNpfllalMqtgaEmsTYaFhT5u7Y/view?usp=drive_link"
         BACKUP  = "https://drive.google.com/file/d/1uRGJCITlfMMN89ZkOO5ICWEKMH24KGit/view?usp=drive_link"
+        TERTIARY = "https://github.com/setiastro/setiastrosuitepro/releases/download/benchmarkFIT/SASPro_Models_Latest.zip"
 
 
         self.btn_models_update.setEnabled(False)
@@ -418,7 +426,7 @@ class SettingsDialog(QDialog):
         from setiastro.saspro.model_workers import ModelsDownloadWorker
 
         self._models_thread = QThread(self)
-        self._models_worker = ModelsDownloadWorker(PRIMARY, BACKUP, expected_sha256=None)
+        self._models_worker = ModelsDownloadWorker(PRIMARY, BACKUP, TERTIARY, expected_sha256=None)
         self._models_worker.moveToThread(self._models_thread)
 
         self._models_thread.started.connect(self._models_worker.run, Qt.ConnectionType.QueuedConnection)
@@ -457,10 +465,39 @@ class SettingsDialog(QDialog):
         if not m:
             self.lbl_models_status.setText(self.tr("Status: not installed"))
             return
-        fid = m.get("file_id", "")
-        self.lbl_models_status.setText(
-            self.tr("Status: installed\nLocation: {0}").format(models_root())
-        )
+
+        # New fields (preferred)
+        src = (m.get("source") or "").strip()
+        ref = (m.get("source_ref") or "").strip()
+        sha = (m.get("sha256") or "").strip()
+
+        # Back-compat with older manifests
+        if not src:
+            # old versions used google_drive + file_id
+            src = "google_drive" if m.get("file_id") else (m.get("source") or "unknown")
+        if not ref:
+            ref = (m.get("file_id") or m.get("file") or "").strip()
+
+        # Keep it short + readable
+        src_label = {
+            "google_drive": "Google Drive",
+            "http": "GitHub/HTTP",
+            "manual_zip": "Manual ZIP",
+        }.get(src, src or "Unknown")
+
+        lines = [self.tr("Status: installed"),
+                self.tr("Location: {0}").format(models_root())]
+
+        if ref:
+            # show just a compact hint (id or url or filename)
+            lines.append(self.tr("Source: {0}").format(src_label))
+            lines.append(self.tr("Ref: {0}").format(ref))
+
+        if sha:
+            lines.append(self.tr("SHA256: {0}").format(sha[:12] + "…"))
+
+        self.lbl_models_status.setText("\n".join(lines))
+        self.lbl_models_status.setStyleSheet("color:#888;")
 
 
     def _accel_pref_changed(self, idx: int):