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

setiastro/saspro/model_manager.py

@@ -17,6 +17,24 @@ APP_FOLDER_NAME = "SetiAstroSuitePro"  # keep stable
 ProgressCB = Optional[Callable[[str], None]]
 
 
+def model_path(filename: str) -> Path:
+    p = Path(models_root()) / filename
+    return p
+
+def require_model(filename: str) -> Path:
+    """
+    Return full path to a runtime-managed model file.
+    Raises FileNotFoundError with a helpful message if missing.
+    """
+    p = model_path(filename)
+    if not p.exists():
+        raise FileNotFoundError(
+            f"Model not found: {p}\n"
+            f"Expected models in: {models_root()}\n"
+            f"Please install/download the Cosmic Clarity models."
+        )
+    return p
+
 def app_data_root() -> str:
     """
     Frozen-safe persistent data root.
@@ -113,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,57 +9,128 @@ import zipfile
 from setiastro.saspro.model_manager import (
     extract_drive_file_id,
     download_google_drive_file,
+    download_http_file,
     install_models_zip,
     sha256_file,
 )
 
+class ModelsInstallZipWorker(QObject):
+    progress = pyqtSignal(str)
+    finished = pyqtSignal(bool, str)
+
+    def __init__(self, zip_path: str, should_cancel=None):
+        super().__init__()
+        self.zip_path = zip_path
+        self.should_cancel = should_cancel  # optional callable
+
+    def run(self):
+        try:
+            from setiastro.saspro.model_manager import install_models_zip, sha256_file
+
+            if not self.zip_path or not os.path.exists(self.zip_path):
+                raise RuntimeError("ZIP file not found.")
+
+            self.progress.emit("Verifying ZIP…")
+            # quick hash (optional but helpful for support logs)
+            zhash = sha256_file(self.zip_path)
+
+            manifest = {
+                "source": "manual_zip",
+                "file": os.path.basename(self.zip_path),
+                "sha256": zhash,
+            }
+
+            install_models_zip(
+                self.zip_path,
+                progress_cb=lambda s: self.progress.emit(s),
+                manifest=manifest,
+            )
+
+            self.finished.emit(True, "Models installed successfully from ZIP.")
+        except Exception as e:
+            self.finished.emit(False, str(e))
+
+
 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

@@ -1,8 +1,9 @@
 # ops.settings.py
 from PyQt6.QtWidgets import (
-    QLineEdit, QDialogButtonBox, QFileDialog, QDialog, QPushButton, QFormLayout,QApplication,
+    QLineEdit, QDialogButtonBox, QFileDialog, QDialog, QPushButton, QFormLayout,QApplication, QMenu,
     QHBoxLayout, QVBoxLayout, QWidget, QCheckBox, QComboBox, QSpinBox, QDoubleSpinBox, QLabel, QColorDialog, QFontDialog, QSlider)
 from PyQt6.QtCore import QSettings, Qt
+from PyQt6.QtGui import QAction
 import pytz  # for timezone list
 from setiastro.saspro.accel_installer import current_backend
 import sys, platform
@@ -12,6 +13,7 @@ from PyQt6.QtCore import QThread
 from setiastro.saspro.i18n import get_available_languages, get_saved_language, save_language
 import importlib.util
 import importlib.metadata
+import webbrowser
 
 class SettingsDialog(QDialog):
     """
@@ -240,7 +242,24 @@ class SettingsDialog(QDialog):
 
         self.btn_models_update = QPushButton(self.tr("Download/Update Models…"))
         self.btn_models_update.clicked.connect(self._models_update_clicked)
-        right_col.addRow(self.btn_models_update)
+
+        self.btn_models_install_zip = QPushButton(self.tr("Install from ZIP…"))
+        self.btn_models_install_zip.setToolTip(self.tr("Use a manually downloaded models .zip file"))
+        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("Download models (Primary/Backup/GitHub mirror)"))
+
+        self.btn_models_open_drive.clicked.connect(self._models_open_drive_clicked)
+
+        row_models = QHBoxLayout()
+        row_models.addWidget(self.btn_models_update, 1)
+        row_models.addWidget(self.btn_models_install_zip)
+        row_models.addWidget(self.btn_models_open_drive)
+
+        w_models = QWidget()
+        w_models.setLayout(row_models)
+        right_col.addRow(w_models)
 
         # ---- Right column: WIMS + RA/Dec + Updates + Display ----
         right_col.addRow(QLabel(self.tr("<b>What's In My Sky — Defaults</b>")))
@@ -298,6 +317,92 @@ class SettingsDialog(QDialog):
         # Initial Load:
         self.refresh_ui()
 
+    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 (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):
+        from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog
+        from PyQt6.QtCore import Qt, QThread
+        import os
+
+        zip_path, _ = QFileDialog.getOpenFileName(
+            self,
+            self.tr("Select models ZIP"),
+            "",
+            self.tr("ZIP files (*.zip);;All files (*)")
+        )
+        if not zip_path:
+            return
+
+        if not os.path.exists(zip_path):
+            QMessageBox.warning(self, self.tr("Models"), self.tr("File not found."))
+            return
+
+        self.btn_models_update.setEnabled(False)
+        self.btn_models_install_zip.setEnabled(False)
+
+        pd = QProgressDialog(self.tr("Preparing…"), self.tr("Cancel"), 0, 0, self)
+        pd.setWindowTitle(self.tr("Installing Models"))
+        pd.setWindowModality(Qt.WindowModality.ApplicationModal)
+        pd.setAutoClose(True)
+        pd.setMinimumDuration(0)
+        pd.show()
+
+        from setiastro.saspro.model_workers import ModelsInstallZipWorker
+
+        self._models_thread = QThread(self)
+        self._models_worker = ModelsInstallZipWorker(zip_path)
+        self._models_worker.moveToThread(self._models_thread)
+
+        self._models_thread.started.connect(self._models_worker.run, Qt.ConnectionType.QueuedConnection)
+        self._models_worker.progress.connect(pd.setLabelText, Qt.ConnectionType.QueuedConnection)
+
+        def _cancel():
+            if self._models_thread.isRunning():
+                self._models_thread.requestInterruption()
+        pd.canceled.connect(_cancel, Qt.ConnectionType.QueuedConnection)
+
+        def _done(ok: bool, msg: str):
+            pd.reset()
+            pd.deleteLater()
+
+            self._models_thread.quit()
+            self._models_thread.wait()
+
+            self.btn_models_update.setEnabled(True)
+            self.btn_models_install_zip.setEnabled(True)
+            self._refresh_models_status()
+
+            if ok:
+                QMessageBox.information(self, self.tr("Models"), self.tr("✅ {0}").format(msg))
+            else:
+                QMessageBox.warning(self, self.tr("Models"), self.tr("❌ {0}").format(msg))
+
+        self._models_worker.finished.connect(_done, Qt.ConnectionType.QueuedConnection)
+        self._models_thread.finished.connect(self._models_worker.deleteLater, Qt.ConnectionType.QueuedConnection)
+        self._models_thread.finished.connect(self._models_thread.deleteLater, Qt.ConnectionType.QueuedConnection)
+
+        self._models_thread.start()
+
+
     def _models_update_clicked(self):
         from PyQt6.QtWidgets import QMessageBox, QProgressDialog
         from PyQt6.QtCore import Qt, QThread
@@ -306,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)
@@ -320,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)
@@ -359,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):

setiastro/saspro/planetprojection.py

@@ -2175,6 +2175,52 @@ class PlanetProjectionDialog(QDialog):
             self._show_stereo_pair(cross_eye=cross_eye)
             return
 
+        # ---- GALAXY TOP-DOWN (early exit) ----
+        # IMPORTANT: do this BEFORE any ROI crop, otherwise huge galaxies get clipped by ROI sizing.
+        is_galaxy = (ptype == 3) or (mode == 5)  # planet_type==Galaxy OR output==Galaxy Polar View
+        if is_galaxy:
+            def to01(x):
+                if x.dtype == np.uint8:
+                    return x.astype(np.float32) / 255.0
+                if x.dtype == np.uint16:
+                    return x.astype(np.float32) / 65535.0
+                return x.astype(np.float32, copy=False)
+
+            roi = img[..., :3]          # FULL IMAGE
+            cx0 = float(cx)             # FULL-IMAGE coords
+            cy0 = float(cy)
+            roi01 = to01(roi)
+
+            pa = float(self.spin_ring_pa.value())      # reuse ring PA widget as galaxy PA
+            tilt = float(self.spin_ring_tilt.value())  # reuse ring tilt widget as galaxy b/a
+
+            # output size: tied to full image (clamped)
+            out_size = int(max(256, min(2400, max(roi.shape[0], roi.shape[1]))))
+
+            try:
+                top8 = deproject_galaxy_topdown_u8(
+                    roi01,
+                    cx0=cx0, cy0=cy0,
+                    rpx=float(r),
+                    pa_deg=pa,
+                    tilt=tilt,
+                    out_size=out_size,
+                )
+            except Exception as e:
+                QMessageBox.warning(self, "Galaxy Polar View", f"Failed to deproject galaxy:\n{e}")
+                return
+
+            # push single-frame output
+            self._left = None
+            self._right = None
+            self._wiggle_frames = None
+            self._wiggle_state = False
+
+            self._last_preview_u8 = top8
+            self._push_preview_u8(top8)
+            return
+
+
         # ---- Saturn rings ROI expansion (only increases s) ----
         is_saturn = (self.cmb_planet_type.currentIndex() == 1)
         rings_on = bool(is_saturn and getattr(self, "chk_rings", None) is not None and self.chk_rings.isChecked())
@@ -2209,6 +2255,28 @@ class PlanetProjectionDialog(QDialog):
         y1 = min(Hfull, y0 + s)
 
         roi = img[y0:y1, x0:x1, :3]
+        # ---- GALAXY ROI expansion (ensure full projected ellipse fits) ----
+        if ptype == 3:
+            tilt = float(self.spin_ring_tilt.value())
+            pa   = float(self.spin_ring_pa.value())
+
+            tilt = float(np.clip(tilt, 0.02, 1.0))
+
+            # ellipse in SOURCE pixels
+            a = float(r)              # semi-major
+            b = max(1.0, a * tilt)    # semi-minor
+
+            th = np.deg2rad(pa)
+            cth, sth = np.cos(th), np.sin(th)
+
+            # bounding half-extents of rotated ellipse
+            dx = np.sqrt((a * cth) ** 2 + (b * sth) ** 2)
+            dy = np.sqrt((a * sth) ** 2 + (b * cth) ** 2)
+            need_half = float(max(dx, dy))
+
+            margin = 12.0
+            s_need = int(np.ceil(2.0 * (need_half + margin)))
+            s = max(s, s_need)
 
         # ---- disk mask (ROI coords) ----
         H0, W0 = roi.shape[:2]
@@ -2226,42 +2294,6 @@ class PlanetProjectionDialog(QDialog):
 
         theta = float(self.spin_theta.value())
 
-        # ---- GALAXY TOP-DOWN (early exit) ----
-        is_galaxy = (ptype == 3) or (mode == 5)  # planet_type==Galaxy OR output==Galaxy Polar View
-
-        if is_galaxy:
-            # Galaxy wants the ROI disk params (cx0, cy0, r) + PA/tilt
-            roi01 = to01(roi)
-
-            pa = float(self.spin_ring_pa.value())      # reuse ring PA widget as galaxy PA
-            tilt = float(self.spin_ring_tilt.value())  # reuse ring tilt widget as galaxy b/a
-
-            # choose output size: use ROI size or clamp to something reasonable
-            out_size = int(max(256, min(2000, max(roi.shape[0], roi.shape[1]))))
-
-            try:
-                top8 = deproject_galaxy_topdown_u8(
-                    roi01,
-                    cx0=float(cx0), cy0=float(cy0),
-                    rpx=float(r),
-                    pa_deg=pa,
-                    tilt=tilt,
-                    out_size=out_size,
-                )
-            except Exception as e:
-                QMessageBox.warning(self, "Galaxy Polar View", f"Failed to deproject galaxy:\n{e}")
-                return
-
-            # push single-frame output
-            self._left = None
-            self._right = None
-            self._wiggle_frames = None
-            self._wiggle_state = False
-
-            self._last_preview_u8 = top8
-            self._push_preview_u8(top8)
-            return
-
         # ---- BODY (sphere reprojection) ----
         interp = cv2.INTER_LANCZOS4
         left_w, right_w, maskL, maskR = make_stereo_pair(

setiastro/saspro/resources.py

@@ -603,23 +603,27 @@ class Resources:
 
 @lru_cache(maxsize=8)
 def get_models_dir() -> str:
-    # Prefer user-installed models
-    try:
-        from setiastro.saspro.model_manager import models_root
-        p = Path(models_root())
-        if p.is_dir():
-            if any(p.rglob("*.pth")) or any(p.rglob("*.onnx")):
-                return str(p)
-    except Exception:
-        pass
+    """
+    Models are NOT packaged resources. They must be installed via the model manager.
+    This returns the user models root and never falls back to _internal/data/models.
+    """
+    from setiastro.saspro.model_manager import models_root
+    p = Path(models_root())
+    # Ensure dir exists (models_root should already do this, but harmless)
+    p.mkdir(parents=True, exist_ok=True)
+    return str(p)
+
 
-    # Fallback to packaged (dev/frozen) path
-    return _resource_path('data/models')
+def _assert_not_internal_models_path(p: str):
+    s = str(p).lower().replace("/", "\\")
+    if "\\_internal\\" in s and "\\data\\models\\" in s:
+        raise RuntimeError(f"Legacy internal model path detected: {p}")
 
 def model_path(filename: str) -> str:
-    base = Path(get_models_dir())
-    path = base / filename
-    return str(path)
+    from setiastro.saspro.model_manager import require_model
+    p = str(require_model(filename))
+    _assert_not_internal_models_path(p)
+    return p
 
 # Export all legacy paths as module-level variables
 _legacy = _init_legacy_paths()