PyPI - setiastrosuitepro - Versions diffs - 1.7.5__py3-none-any.whl → 1.8.0__py3-none-any.whl - Mend

setiastrosuitepro 1.7.5py3-none-any.whl → 1.8.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

setiastro/saspro/_generated/build_info.py +2 -2
setiastro/saspro/accel_installer.py +21 -8
setiastro/saspro/accel_workers.py +11 -12
setiastro/saspro/blink_comparator_pro.py +146 -2
setiastro/saspro/comet_stacking.py +113 -85
setiastro/saspro/cosmicclarity.py +604 -826
setiastro/saspro/cosmicclarity_engines/benchmark_engine.py +715 -0
setiastro/saspro/cosmicclarity_engines/darkstar_engine.py +576 -0
setiastro/saspro/cosmicclarity_engines/denoise_engine.py +567 -0
setiastro/saspro/cosmicclarity_engines/satellite_engine.py +620 -0
setiastro/saspro/cosmicclarity_engines/sharpen_engine.py +587 -0
setiastro/saspro/cosmicclarity_engines/superres_engine.py +412 -0
setiastro/saspro/gui/main_window.py +14 -0
setiastro/saspro/gui/mixins/menu_mixin.py +2 -0
setiastro/saspro/model_manager.py +306 -0
setiastro/saspro/model_workers.py +65 -0
setiastro/saspro/ops/benchmark.py +320 -0
setiastro/saspro/ops/settings.py +308 -9
setiastro/saspro/remove_stars.py +424 -442
setiastro/saspro/resources.py +73 -10
setiastro/saspro/runtime_torch.py +107 -22
setiastro/saspro/signature_insert.py +14 -3
setiastro/saspro/stacking_suite.py +539 -115
{setiastrosuitepro-1.7.5.dist-info → setiastrosuitepro-1.8.0.dist-info}/METADATA +2 -1
{setiastrosuitepro-1.7.5.dist-info → setiastrosuitepro-1.8.0.dist-info}/RECORD +29 -20
{setiastrosuitepro-1.7.5.dist-info → setiastrosuitepro-1.8.0.dist-info}/WHEEL +0 -0
{setiastrosuitepro-1.7.5.dist-info → setiastrosuitepro-1.8.0.dist-info}/entry_points.txt +0 -0
{setiastrosuitepro-1.7.5.dist-info → setiastrosuitepro-1.8.0.dist-info}/licenses/LICENSE +0 -0
{setiastrosuitepro-1.7.5.dist-info → setiastrosuitepro-1.8.0.dist-info}/licenses/license.txt +0 -0

setiastro/saspro/model_manager.py ADDED Viewed

@@ -0,0 +1,306 @@
+# src/setiastro/saspro/model_manager.py
+from __future__ import annotations
+import os
+import re
+import json
+import time
+import shutil
+import hashlib
+import zipfile
+import tempfile
+from typing import Optional, Callable
+from urllib.parse import urlparse, parse_qs
+from pathlib import Path
+APP_FOLDER_NAME = "SetiAstroSuitePro"  # keep stable
+ProgressCB = Optional[Callable[[str], None]]
+def app_data_root() -> str:
+    """
+    Frozen-safe persistent data root.
+    MUST match the benchmark cache dir base (runtime_torch._user_runtime_dir()).
+    Example on Windows:
+      C:\\Users\\YOU\\AppData\\Local\\SASpro
+    """
+    from setiastro.saspro.runtime_torch import _user_runtime_dir
+    root = Path(_user_runtime_dir())  # this is what benchmark_cache_dir() uses
+    root.mkdir(parents=True, exist_ok=True)
+    return str(root)
+def models_root() -> str:
+    p = Path(app_data_root()) / "models"
+    p.mkdir(parents=True, exist_ok=True)
+    return str(p)
+def installed_manifest_path() -> str:
+    return str(Path(models_root()) / "manifest.json")
+def read_installed_manifest() -> dict:
+    try:
+        with open(installed_manifest_path(), "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+def write_installed_manifest(d: dict) -> None:
+    try:
+        with open(installed_manifest_path(), "w", encoding="utf-8") as f:
+            json.dump(d, f, indent=2)
+    except Exception:
+        pass
+# ---------------- Google Drive helpers ----------------
+_DRIVE_FILE_RE = re.compile(r"/file/d/([a-zA-Z0-9_-]+)")
+_DRIVE_ID_RE = re.compile(r"[?&]id=([a-zA-Z0-9_-]+)")
+def extract_drive_file_id(url_or_id: str) -> Optional[str]:
+    s = (url_or_id or "").strip()
+    if not s:
+        return None
+    # raw id
+    if re.fullmatch(r"[0-9A-Za-z_-]{10,}", s):
+        return s
+    try:
+        u = urlparse(s)
+        if "drive.google.com" not in (u.netloc or "") and "docs.google.com" not in (u.netloc or ""):
+            return None
+        m = re.search(r"/file/d/([^/]+)", u.path or "")
+        if m:
+            return m.group(1)
+        qs = parse_qs(u.query or "")
+        if "id" in qs and qs["id"]:
+            return qs["id"][0]
+    except Exception:
+        return None
+    return None
+def _looks_like_html_prefix(b: bytes) -> bool:
+    head = (b or b"").lstrip()[:256].lower()
+    return head.startswith(b"<!doctype html") or head.startswith(b"<html") or (b"<html" in head)
+def _parse_gdrive_download_form(html: str) -> tuple[Optional[str], Optional[dict]]:
+    m = re.search(r'<form[^>]+id="download-form"[^>]+action="([^"]+)"', html)
+    if not m:
+        return None, None
+    action = m.group(1)
+    params: dict[str, str] = {}
+    for name, val in re.findall(
+        r'<input[^>]+type="hidden"[^>]+name="([^"]+)"[^>]*value="([^"]*)"', html
+    ):
+        params[name] = val
+    for name in re.findall(
+        r'<input[^>]+type="hidden"[^>]+name="([^"]+)"(?![^>]*value=)', html
+    ):
+        params.setdefault(name, "")
+    return action, params
+def download_google_drive_file(
+    file_id: str,
+    dst_path: str | os.PathLike,
+    *,
+    progress_cb: ProgressCB = None,
+    should_cancel=None,  # callable -> bool
+    timeout: int = 60,
+    chunk_size: int = 1024 * 1024,
+) -> Path:
+    """
+    Downloads a Google Drive file by ID, handling virus-scan interstitial HTML.
+    Writes atomically (dst.part -> dst).
+    """
+    import requests  # local import to keep import cost down
+    fid = extract_drive_file_id(file_id) or file_id
+    if not fid:
+        raise RuntimeError("No Google Drive file id provided.")
+    dst = Path(dst_path)
+    tmp = dst.with_suffix(dst.suffix + ".part")
+    tmp.parent.mkdir(parents=True, exist_ok=True)
+    # The “uc” endpoint is best for download
+    url = f"https://drive.google.com/uc?export=download&id={fid}"
+    def log(msg: str):
+        if progress_cb:
+            progress_cb(msg)
+    # Clean any old partial
+    try:
+        tmp.unlink(missing_ok=True)
+    except Exception:
+        pass
+    with requests.Session() as s:
+        log("Connecting to Google Drive…")
+        r = s.get(url, stream=True, timeout=timeout, allow_redirects=True)
+        ctype = (r.headers.get("Content-Type") or "").lower()
+        # If HTML, parse the interstitial "download anyway" form and re-request.
+        if "text/html" in ctype:
+            html = r.text
+            r.close()
+            action, params = _parse_gdrive_download_form(html)
+            if not action or not params:
+                raise RuntimeError(
+                    "Google Drive returned an interstitial HTML page, but the download form could not be parsed."
+                )
+            log("Google Drive interstitial detected — confirming download…")
+            r = s.get(action, params=params, 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
+        first = True
+        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
+                if first:
+                    first = False
+                    # extra safety: even if content-type lies
+                    if _looks_like_html_prefix(chunk[:256]):
+                        raise RuntimeError(
+                            "Google Drive returned HTML instead of the file (permission/confirm issue)."
+                        )
+                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 install_models_zip(
+    zip_path: str | os.PathLike,
+    *,
+    progress_cb: ProgressCB = None,
+    manifest: dict | None = None,
+) -> None:
+    """
+    Extracts a models zip and installs it into models_root(), replacing previous contents.
+    Writes manifest.json if provided.
+    """
+    dst = Path(models_root())
+    # Use unique temp dirs per install to avoid collisions
+    tmp_extract = Path(tempfile.gettempdir()) / f"saspro_models_extract_{os.getpid()}_{int(time.time())}"
+    tmp_stage = Path(tempfile.gettempdir()) / f"saspro_models_stage_{os.getpid()}_{int(time.time())}"
+    def log(msg: str):
+        if progress_cb:
+            progress_cb(msg)
+    # clean temp (best-effort)
+    try:
+        shutil.rmtree(tmp_extract, ignore_errors=True)
+        shutil.rmtree(tmp_stage, ignore_errors=True)
+    except Exception:
+        pass
+    try:
+        log("Extracting models zip…")
+        tmp_extract.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(str(zip_path), "r") as z:
+            z.extractall(tmp_extract)
+        # Some zips contain a top-level folder; normalize:
+        root = tmp_extract
+        kids = list(root.iterdir())
+        if len(kids) == 1 and kids[0].is_dir():
+            root = kids[0]
+        # sanity: must contain at least one model file
+        any_model = any(p.suffix.lower() in (".pth", ".onnx") for p in root.rglob("*"))
+        if not any_model:
+            raise RuntimeError("Models zip did not contain any .pth/.onnx files.")
+        log(f"Installing to: {dst}")
+        # Stage copy
+        shutil.copytree(root, tmp_stage)
+        # Clear destination contents (keep dst folder stable)
+        dst.mkdir(parents=True, exist_ok=True)
+        for item in dst.iterdir():
+            try:
+                if item.is_dir():
+                    shutil.rmtree(item, ignore_errors=True)
+                else:
+                    item.unlink(missing_ok=True)
+            except Exception:
+                pass
+        # Copy staged contents into dst
+        for item in tmp_stage.iterdir():
+            target = dst / item.name
+            if item.is_dir():
+                # dirs_exist_ok requires Python 3.8+, you're on 3.12 so OK
+                shutil.copytree(item, target, dirs_exist_ok=True)
+            else:
+                shutil.copy2(item, target)
+        if manifest:
+            log("Writing manifest…")
+            write_installed_manifest(manifest)
+        log("Models installed.")
+    finally:
+        shutil.rmtree(tmp_extract, ignore_errors=True)
+        shutil.rmtree(tmp_stage, ignore_errors=True)
+def sha256_file(path: str | os.PathLike, *, chunk_size: int = 1024 * 1024) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(chunk_size)
+            if not b:
+                break
+            h.update(b)
+    return h.hexdigest()

setiastro/saspro/model_workers.py ADDED Viewed

@@ -0,0 +1,65 @@
+# src/setiastro/saspro/model_workers.py
+from __future__ import annotations
+from PyQt6.QtCore import QObject, pyqtSignal
+import os
+import tempfile
+import zipfile
+from setiastro.saspro.model_manager import (
+    extract_drive_file_id,
+    download_google_drive_file,
+    install_models_zip,
+    sha256_file,
+)
+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):
+        super().__init__()
+        self.primary = primary
+        self.backup = backup
+        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
+            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}")
+            manifest = {
+                "source": "google_drive",
+                "file_id": fid,
+                "sha256": self.expected_sha256,
+            }
+            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/benchmark.py ADDED Viewed

@@ -0,0 +1,320 @@
+# src/setiastro/saspro/ops/benchmark.py
+from __future__ import annotations
+import json
+from PyQt6.QtCore import QThread, pyqtSignal, QObject
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QComboBox,
+    QProgressBar, QTextEdit, QMessageBox, QApplication
+)
+from setiastro.saspro.cosmicclarity_engines.benchmark_engine import (
+    benchmark_image_path, download_benchmark_image, run_benchmark,  # keep your run_benchmark
+)
+from setiastro.saspro.cosmicclarity_engines.benchmark_engine import BENCHMARK_FITS_URL  # or define here
+class _BenchWorker(QObject):
+    log = pyqtSignal(str)
+    prog = pyqtSignal(int, int)          # done,total
+    done = pyqtSignal(bool, dict, str)   # ok, results, err
+    def __init__(self, mode: str, use_gpu: bool):
+        super().__init__()
+        self.mode = mode
+        self.use_gpu = use_gpu
+    def run(self):
+        try:
+            def status_cb(s: str):
+                self.log.emit(str(s))
+            def progress_cb(done: int, total: int) -> bool:
+                self.prog.emit(int(done), int(total))
+                return not QThread.currentThread().isInterruptionRequested()
+            results = run_benchmark(
+                mode=self.mode,
+                use_gpu=self.use_gpu,
+                status_cb=status_cb,
+                progress_cb=progress_cb,
+            )
+            self.done.emit(True, results, "")
+        except Exception as e:
+            msg = str(e)
+            if "Canceled" in msg or "cancel" in msg.lower():
+                self.done.emit(False, {}, "Canceled.")
+            else:
+                self.done.emit(False, {}, msg)
+class _DownloadWorker(QObject):
+    log = pyqtSignal(str)
+    prog = pyqtSignal(int, int)          # bytes_done, bytes_total
+    done = pyqtSignal(bool, str)         # ok, message/path
+    def __init__(self, url: str):
+        super().__init__()
+        self.url = url
+    def run(self):
+        try:
+            def status_cb(s: str):
+                self.log.emit(str(s))
+            def progress_cb(done: int, total: int):
+                self.prog.emit(int(done), int(total))
+            def cancel_cb() -> bool:
+                return QThread.currentThread().isInterruptionRequested()
+            p = download_benchmark_image(
+                None,
+                status_cb=status_cb,
+                progress_cb=progress_cb,
+                cancel_cb=cancel_cb,
+            )
+            self.done.emit(True, str(p))
+        except Exception as e:
+            self.done.emit(False, str(e))
+class BenchmarkDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Seti Astro Benchmark")
+        self.setModal(False)
+        self.setMinimumSize(560, 520)
+        self._results = None
+        self._thread = None
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(10, 10, 10, 10)
+        outer.setSpacing(8)
+        # Top row: image status + download
+        top = QHBoxLayout()
+        self.lbl_img = QLabel(self)
+        self.btn_dl = QPushButton("Download Benchmark Image…", self)
+        self.btn_dl.clicked.connect(self._download_image)
+        top.addWidget(self.lbl_img, 1)
+        top.addWidget(self.btn_dl)
+        outer.addLayout(top)
+        # Mode row
+        row = QHBoxLayout()
+        row.addWidget(QLabel("Run:", self))
+        self.cmb = QComboBox(self)
+        self.cmb.addItems(["CPU", "GPU", "Both"])
+        self.cmb.setCurrentText("Both")
+        row.addWidget(self.cmb)
+        self.btn_run = QPushButton("Run Benchmark", self)
+        self.btn_run.clicked.connect(self._run_benchmark)
+        row.addWidget(self.btn_run)
+        row.addStretch(1)
+        outer.addLayout(row)
+        # Progress
+        self.pbar = QProgressBar(self)
+        self.pbar.setRange(0, 100)
+        outer.addWidget(self.pbar)
+        # Log / results
+        self.txt = QTextEdit(self)
+        self.txt.setReadOnly(True)
+        outer.addWidget(self.txt, 1)
+        # Bottom buttons
+        bot = QHBoxLayout()
+        self.btn_copy = QPushButton("Copy JSON", self)
+        self.btn_copy.setEnabled(False)
+        self.btn_copy.clicked.connect(self._copy_json)
+        self.btn_save = QPushButton("Save Locally", self)
+        self.btn_save.setEnabled(False)
+        self.btn_save.clicked.connect(self._save_local)
+        self.btn_submit = QPushButton("Submit…", self)
+        self.btn_submit.clicked.connect(self._submit)
+        self.btn_close = QPushButton("Close", self)
+        self.btn_close.clicked.connect(self.close)
+        bot.addWidget(self.btn_copy)
+        bot.addWidget(self.btn_save)
+        bot.addStretch(1)
+        bot.addWidget(self.btn_submit)
+        bot.addWidget(self.btn_close)
+        outer.addLayout(bot)
+        self.refresh_ui()
+    def refresh_ui(self):
+        p = benchmark_image_path()
+        if p.exists():
+            self.lbl_img.setText(f"Benchmark image: Ready ({p.name})")
+            self.btn_run.setEnabled(True)
+        else:
+            self.lbl_img.setText("Benchmark image: Not downloaded")
+            self.btn_run.setEnabled(False)
+        self.pbar.setValue(0)
+    # ---------- download ----------
+    def _download_image(self):
+        self._stop_thread_if_any()
+        self.txt.append("Starting download…")
+        self.btn_dl.setEnabled(False)
+        self.btn_run.setEnabled(False)
+        self.pbar.setValue(0)
+        t = QThread(self)
+        w = _DownloadWorker(BENCHMARK_FITS_URL)
+        w.moveToThread(t)
+        w.log.connect(self._log)
+        w.prog.connect(self._dl_progress)
+        w.done.connect(lambda ok, msg: self._dl_done(ok, msg, t, w))
+        t.started.connect(w.run)
+        t.start()
+        self._thread = t
+    def _dl_progress(self, done: int, total: int):
+        if total > 0:
+            pct = int(done * 100 / total)
+            self.pbar.setRange(0, 100)
+            self.pbar.setValue(max(0, min(100, pct)))
+            # 👇 add this
+            self.pbar.setFormat(f"{pct}%  ({done/1e6:.0f}/{total/1e6:.0f} MB)")
+        else:
+            # unknown length
+            self.pbar.setRange(0, 0)
+            self.pbar.setFormat(f"{done/1e6:.0f} MB")
+    def _dl_done(self, ok: bool, msg: str, t: QThread, w: QObject):
+        t.quit(); t.wait()
+        self._thread = None
+        self.pbar.setRange(0, 100)
+        self.pbar.setFormat("%p%")
+        self.btn_dl.setEnabled(True)
+        if ok:
+            self._log(f"✅ Downloaded: {msg}")
+            self.refresh_ui()
+        else:
+            self._log(f"❌ Download failed: {msg}")
+            QMessageBox.warning(self, "Download failed", msg)
+            self.refresh_ui()
+    def closeEvent(self, e):
+        self._stop_thread_if_any()
+        self.pbar.setRange(0, 100)
+        super().closeEvent(e)
+    # ---------- run benchmark ----------
+    def _run_benchmark(self):
+        p = benchmark_image_path()
+        if not p.exists():
+            QMessageBox.information(self, "Benchmark image missing", "Please download the benchmark image first.")
+            return
+        self._stop_thread_if_any()
+        self.btn_run.setEnabled(False)
+        self.btn_dl.setEnabled(False)
+        self._results = None
+        self.btn_copy.setEnabled(False)
+        self.btn_save.setEnabled(False)
+        self.txt.clear()
+        self._log("Running benchmark…")
+        self.pbar.setValue(0)
+        mode = self.cmb.currentText()
+        use_gpu = True  # benchmark engine will pick CPU if no CUDA/DML
+        t = QThread(self)
+        w = _BenchWorker(mode=mode, use_gpu=use_gpu)
+        w.moveToThread(t)
+        w.log.connect(self._log)
+        w.prog.connect(self._bench_progress)
+        w.done.connect(lambda ok, results, err: self._bench_done(ok, results, err, t, w))
+        t.started.connect(w.run)
+        t.start()
+        self._thread = t
+    def _bench_progress(self, done: int, total: int):
+        if total > 0:
+            self.pbar.setValue(int(done * 100 / total))
+        QApplication.processEvents()
+    def _bench_done(self, ok: bool, results: dict, err: str, t: QThread, w: QObject):
+        t.quit(); t.wait()
+        self._thread = None
+        self.pbar.setValue(100 if ok else 0)
+        self.btn_run.setEnabled(True)
+        self.btn_dl.setEnabled(True)
+        if not ok:
+            self._log(f"❌ Benchmark failed: {err}")
+            if str(err).strip().lower().startswith("canceled"):
+                # no scary dialog for user-cancel
+                self.pbar.setValue(0)
+                return
+            QMessageBox.warning(self, "Benchmark failed", err)
+            return
+        self._results = results
+        self._log("✅ Benchmark complete.\n")
+        self._log(json.dumps([results], indent=2))
+        self.btn_copy.setEnabled(True)
+        self.btn_save.setEnabled(True)
+    # ---------- actions ----------
+    def _copy_json(self):
+        if not self._results:
+            return
+        s = json.dumps([self._results], indent=4)
+        QApplication.clipboard().setText(s)
+        QMessageBox.information(self, "Copied", "Benchmark JSON copied to clipboard.")
+    def _save_local(self):
+        if not self._results:
+            return
+        # reuse your existing helper if you want; simplest local save:
+        import os, time
+        fn = "benchmark_results.json"
+        try:
+            if os.path.exists(fn):
+                with open(fn, "r", encoding="utf-8") as f:
+                    try:
+                        allr = json.load(f)
+                    except Exception:
+                        allr = []
+            else:
+                allr = []
+            allr.append(self._results)
+            with open(fn, "w", encoding="utf-8") as f:
+                json.dump(allr, f, indent=4)
+            self._log(f"\n✅ Saved to {fn}")
+        except Exception as e:
+            QMessageBox.warning(self, "Save failed", str(e))
+    def _submit(self):
+        import webbrowser
+        webbrowser.open("https://setiastro.com/benchmark-submit")
+    def _log(self, s: str):
+        self.txt.append(str(s))
+    def _stop_thread_if_any(self):
+        if self._thread is not None and self._thread.isRunning():
+            self._thread.requestInterruption()
+            self._thread.quit()
+            self._thread.wait()
+        self._thread = None

setiastrosuitepro 1.7.5__py3-none-any.whl → 1.8.0__py3-none-any.whl

setiastrosuitepro 1.7.5py3-none-any.whl → 1.8.0py3-none-any.whl