setiastrosuitepro 1.6.0__py3-none-any.whl

setiastro/saspro/aberration_ai_preset.py

@@ -0,0 +1,224 @@
+# pro/aberration_ai_preset.py
+from __future__ import annotations
+import os
+import time
+import numpy as np
+from PyQt6.QtCore import QTimer
+from PyQt6.QtWidgets import QDialog, QVBoxLayout, QProgressBar, QPushButton, QMessageBox, QFormLayout, QDialogButtonBox, QSpinBox, QCheckBox, QComboBox, QLabel
+
+from PyQt6.QtCore import QSettings
+# reuse everything from the UI module
+from .aberration_ai import (
+    ort, IS_APPLE_ARM,
+    _ONNXWorker, pick_providers, _preserve_border
+)
+
+# ---------------------- Headless entry ----------------------
+
+def run_aberration_ai_via_preset(main, preset: dict | None = None, doc=None):
+    """
+    Headless Aberration AI
+
+    preset keys (all optional except model):
+      - model: str (path to .onnx). If omitted, uses QSettings "AberrationAI/model_path".
+      - patch: int (default 512)
+      - overlap: int (default 64)
+      - border_px: int (default 10)
+      - auto_gpu: bool (default True; forced False on Apple Silicon)
+      - provider: str (used when auto_gpu=False), e.g. "CPUExecutionProvider",
+                  "CUDAExecutionProvider", "DmlExecutionProvider"
+    """
+    if ort is None:
+        QMessageBox.critical(main, "Aberration AI", "onnxruntime not installed.")
+        return
+
+    # active doc
+    if doc is None:
+        d = getattr(main, "_active_doc", None)
+        doc = d() if callable(d) else d
+
+    if doc is None or getattr(doc, "image", None) is None:
+        QMessageBox.warning(main, "Aberration AI", "Load an image first.")
+        return
+
+    p = dict(preset or {})
+
+    # model path (preset beats QSettings)
+    model = p.get("model") or QSettings().value("AberrationAI/model_path", type=str)
+    if not model or not os.path.isfile(model):
+        QMessageBox.warning(main, "Aberration AI", "Model not set. Open the Aberration AI tool once and choose a model, or put 'model' into the preset.")
+        return
+
+    patch    = int(p.get("patch", 512))
+    overlap  = int(p.get("overlap", 64))
+    border_px= int(p.get("border_px", 10))
+
+    # providers
+    if IS_APPLE_ARM:
+        providers = ["CPUExecutionProvider"]
+        auto_gpu = False
+        provider_label = "CPUExecutionProvider"
+    else:
+        auto_gpu = bool(p.get("auto_gpu", True))
+        if auto_gpu:
+            providers = pick_providers(auto_gpu=True)
+            provider_label = "auto"
+        else:
+            sel = str(p.get("provider", "CPUExecutionProvider"))
+            providers = [sel]
+            provider_label = sel or "CPUExecutionProvider"
+
+    # Safety for CoreML if someone forces it
+    if "CoreMLExecutionProvider" in providers and patch > 128:
+        patch = 128
+
+    # Guard so interactive dialog won't pop during/after apply
+    setattr(main, "_aberration_ai_headless_running", True)
+    setattr(main, "_aberration_ai_guard", True)
+
+    # ---- minimal progress dialog ----
+    dlg = QDialog(main)
+    dlg.setWindowTitle("Aberration AI (Headless)")
+    lay = QVBoxLayout(dlg)
+    bar = QProgressBar(); bar.setRange(0, 100); lay.addWidget(bar)
+    btn = QPushButton("Cancel"); lay.addWidget(btn)
+
+    img = np.asarray(doc.image)
+    orig_for_border = img.copy()
+
+    t0 = time.perf_counter()
+
+    worker = _ONNXWorker(model, img, patch, overlap, providers)
+    worker.progressed.connect(bar.setValue)
+
+    def _fail(msg: str):
+        try:
+            if hasattr(main, "_log"):
+                main._log(f"❌ Aberration AI failed: {msg}")
+        except Exception:
+            pass
+        QMessageBox.critical(main, "Aberration AI", msg)
+        dlg.close()
+
+    def _ok(out: np.ndarray):
+        # preserve border and commit
+        try:
+            out2 = _preserve_border(out, orig_for_border, border_px)
+        except Exception:
+            out2 = out
+
+        meta = {
+            "is_mono": (out2.ndim == 2),
+            "processing_parameters": {
+                "AberrationAI": {
+                    "model_path": model,
+                    "patch_size": int(patch),
+                    "overlap": int(overlap),
+                    "provider": provider_label,
+                    "border_px": int(border_px),
+                }
+            }
+        }
+        try:
+            doc.apply_edit(out2, meta, step_name="Aberration AI")
+            used = getattr(worker, "used_provider", provider_label)
+            dt = time.perf_counter() - t0
+            if hasattr(main, "_log"):
+                main._log(
+                    f"✅ Aberration AI (headless) model={os.path.basename(model)}, "
+                    f"provider={used}, patch={patch}, overlap={overlap}, "
+                    f"border={border_px}px, time={dt:.2f}s"
+                )
+
+            # ---- Register as last_headless_command for Replay ----
+            try:
+                auto_flag = bool(auto_gpu)
+                replay_preset = {
+                    "model": model,
+                    "patch": int(patch),
+                    "overlap": int(overlap),
+                    "border_px": int(border_px),
+                    "auto_gpu": auto_flag,
+                }
+                if not auto_flag:
+                    replay_preset["provider"] = provider_label
+
+                payload = {
+                    "command_id": "aberrationai",
+                    "preset": replay_preset,
+                }
+                setattr(main, "_last_headless_command", payload)
+            except Exception:
+                pass
+            # -------------------------------------------------------
+        except Exception as e:
+            QMessageBox.critical(main, "Aberration AI", f"Failed to apply result:\n{e}")
+        finally:
+            dlg.close()
+
+    worker.failed.connect(_fail)
+    worker.finished_ok.connect(_ok)
+    worker.finished.connect(lambda: btn.setEnabled(False))
+    btn.clicked.connect(worker.terminate)
+
+    worker.start()
+    dlg.exec()
+
+    # clear the guard after a brief tick so downstream signals don’t re-open UI
+    def _clear():
+        for k in ("_aberration_ai_headless_running", "_aberration_ai_guard"):
+            try: delattr(main, k)
+            except Exception: setattr(main, k, False)
+    QTimer.singleShot(1000, _clear)
+
+
+# ---------------------- Preset editor (for shortcut) ----------------------
+
+class AberrationAIPresetDialog(QDialog):
+    def __init__(self, parent=None, initial: dict | None = None):
+        super().__init__(parent)
+        self.setWindowTitle("Aberration AI — Preset")
+        p = dict(initial or {})
+
+        self.spin_patch   = QSpinBox(); self.spin_patch.setRange(128, 2048); self.spin_patch.setValue(int(p.get("patch", 512)))
+        self.spin_overlap = QSpinBox(); self.spin_overlap.setRange(16, 512);  self.spin_overlap.setValue(int(p.get("overlap", 64)))
+        self.spin_border  = QSpinBox(); self.spin_border.setRange(0, 64);     self.spin_border.setValue(int(p.get("border_px", 10)))
+
+        self.chk_auto = QCheckBox("Auto GPU (prefer DML/CUDA)"); self.chk_auto.setChecked(bool(p.get("auto_gpu", True)))
+        self.cmb_provider = QComboBox(); self.cmb_provider.addItems([
+            "CPUExecutionProvider", "DmlExecutionProvider", "CUDAExecutionProvider", "CoreMLExecutionProvider"
+        ])
+        self.cmb_provider.setCurrentText(str(p.get("provider", "CPUExecutionProvider")))
+
+        # info: model is taken from QSettings unless preset provides an absolute path from code
+        info = QLabel("Model path is taken from the Aberration AI tool (QSettings) unless you pass 'model' in the preset programmatically.")
+        info.setWordWrap(True); info.setStyleSheet("color:#888; font-size:11px;")
+
+        form = QFormLayout(self)
+        form.addRow("Patch:", self.spin_patch)
+        form.addRow("Overlap:", self.spin_overlap)
+        form.addRow("Preserve border (px):", self.spin_border)
+        form.addRow(self.chk_auto)
+        form.addRow("Provider (if Auto off):", self.cmb_provider)
+        form.addRow(info)
+
+        btns = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self)
+        btns.accepted.connect(self.accept); btns.rejected.connect(self.reject)
+        form.addRow(btns)
+
+        # toggle enable
+        def _toggle():
+            en = not self.chk_auto.isChecked()
+            self.cmb_provider.setEnabled(en)
+        self.chk_auto.stateChanged.connect(lambda _: _toggle()); _toggle()
+
+    def result_dict(self) -> dict:
+        d = {
+            "patch": int(self.spin_patch.value()),
+            "overlap": int(self.spin_overlap.value()),
+            "border_px": int(self.spin_border.value()),
+            "auto_gpu": bool(self.chk_auto.isChecked()),
+        }
+        if not d["auto_gpu"]:
+            d["provider"] = self.cmb_provider.currentText()
+        return d

setiastro/saspro/accel_installer.py

@@ -0,0 +1,218 @@
+# pro/accel_installer.py
+from __future__ import annotations
+import platform
+import subprocess
+import sys
+import os
+from typing import Callable, Optional
+from PyQt6.QtWidgets import QMessageBox
+from setiastro.saspro.runtime_torch import import_torch, add_runtime_to_sys_path, _user_runtime_dir, _venv_paths
+
+LogCB = Callable[[str], None]
+
+def _run(cmd):
+    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+
+
+def _has_intel_arc() -> bool:
+    """
+    Return True if the machine appears to have an Intel Arc / Xe (XPU-capable) adapter.
+    Windows: CIM/WMIC name sniff.
+    Linux: lspci grep.
+    macOS: False.
+    """
+    try:
+        sysname = platform.system()
+        if sysname == "Windows":
+            ps = _run(["powershell","-NoProfile","-Command",
+                       "(Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name) -join ';'"])
+            out = (ps.stdout or "").lower()
+            # Accept 'arc' or 'iris xe' (dg/xe discrete & some laptops with XPU)
+            return ("intel" in out) and ("arc" in out or "iris xe" in out or "a770" in out or "a750" in out or "a580" in out or "a380" in out)
+        if sysname == "Linux":
+            r = _run(["bash","-lc","lspci -nn | grep -i 'vga\\|3d'"])
+            s = (r.stdout or "").lower()
+            return ("intel" in s) and ("arc" in s or "iris xe" in s or "xe" in s)
+        return False
+    except Exception:
+        return False
+
+def _has_nvidia() -> bool:
+    """
+    Return True if the machine *appears* to have an NVIDIA adapter.
+    Windows: try PowerShell CIM first (wmic is deprecated), then wmic.
+    Linux: use nvidia-smi.
+    macOS: always False.
+    """
+    try:
+      sysname = platform.system()
+      if sysname == "Windows":
+          # Try CIM (preferred)
+          ps = _run(["powershell","-NoProfile","-Command",
+                     "(Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name) -join ';'"])
+          out = (ps.stdout or "").lower()
+          if "nvidia" in out:
+              return True
+          # Fallback to wmic (older systems)
+          w = _run(["wmic","path","win32_VideoController","get","name"])
+          return "nvidia" in (w.stdout or "").lower()
+      if sysname == "Linux":
+          r = _run(["nvidia-smi","-L"])
+          return "GPU" in (r.stdout or "")
+      return False
+    except Exception:
+      return False
+
+def _nvidia_driver_ok(log_cb: LogCB) -> bool:
+    try:
+        r = _run(["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"])
+        drv = (r.stdout or "").strip()
+        if not drv:
+            log_cb("nvidia-smi not found or driver not detected.")
+            return False
+        log_cb(f"NVIDIA driver detected: {drv}")
+        return True
+    except Exception:
+        log_cb("Unable to query NVIDIA driver via nvidia-smi.")
+        return False
+
+
+def ensure_torch_installed(prefer_gpu: bool, log_cb: LogCB) -> tuple[bool, Optional[str]]:
+    try:
+        is_windows = platform.system() == "Windows"
+        has_nv = _has_nvidia() and platform.system() in ("Windows", "Linux")
+        has_intel = (not has_nv) and _has_intel_arc() and platform.system() in ("Windows", "Linux")
+
+        prefer_cuda = prefer_gpu and has_nv
+        prefer_xpu  = prefer_gpu and (not has_nv) and has_intel
+
+        if prefer_cuda and not _nvidia_driver_ok(log_cb):
+            log_cb("CUDA requested but NVIDIA driver not detected/working; CUDA wheels may not initialize.")
+        log_cb(f"PyTorch install preference: prefer_cuda={prefer_cuda}, prefer_xpu={prefer_xpu} (OS={platform.system()})")
+
+        # Install torch (tries CUDA → XPU → CPU)
+        torch = import_torch(prefer_cuda=prefer_cuda, prefer_xpu=prefer_xpu, status_cb=log_cb)
+
+        cuda_ok = bool(getattr(torch, "cuda", None) and torch.cuda.is_available())
+        xpu_ok  = bool(hasattr(torch, "xpu") and torch.xpu.is_available())
+
+        # HARD RULES about DirectML:
+        # • If NVIDIA exists: never use DML.
+        # • If XPU is active: also avoid DML to prevent confusion.
+        if has_nv:
+            _maybe_uninstall_dml = True
+        else:
+            _maybe_uninstall_dml = xpu_ok
+
+        if _maybe_uninstall_dml:
+            try:
+                from setiastro.saspro.runtime_torch import _user_runtime_dir, _venv_paths
+                rt = _user_runtime_dir(); vpy = _venv_paths(rt)["python"]
+                r = subprocess.run([str(vpy), "-m", "pip", "show", "torch-directml"],
+                                   stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+                if r.returncode == 0 and r.stdout:
+                    log_cb("Non-DML path selected → uninstalling torch-directml.")
+                    subprocess.run([str(vpy), "-m", "pip", "uninstall", "-y", "torch-directml"],
+                                   stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+            except Exception:
+                pass
+
+        if cuda_ok:
+            log_cb("CUDA available; using NVIDIA backend.")
+            return True, None
+
+        if xpu_ok:
+            # optional: surface device name if available
+            try:
+                name = None
+                if hasattr(torch.xpu, "get_device_name"):
+                    name = torch.xpu.get_device_name(0)
+                log_cb(f"Intel XPU available{f' ({name})' if name else ''}.")
+            except Exception:
+                log_cb("Intel XPU available.")
+            return True, None
+
+        # No CUDA/XPU ⇒ evaluate DML on Windows non-NVIDIA as before
+        dml_enabled = False
+        if is_windows and (not has_nv):
+            try:
+                import importlib; importlib.invalidate_caches()
+                import torch_directml  # noqa
+                dml_enabled = True
+                log_cb("DirectML detected (already installed).")
+            except Exception:
+                from setiastro.saspro.runtime_torch import _user_runtime_dir, _venv_paths
+                rt = _user_runtime_dir(); vpy = _venv_paths(rt)["python"]
+                log_cb("Installing torch-directml (Windows fallback)…")
+                r = subprocess.run([str(vpy), "-m", "pip", "install", "--prefer-binary", "torch-directml"],
+                                   stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+                if r.returncode == 0:
+                    try:
+                        import importlib; importlib.invalidate_caches()
+                        import torch_directml  # noqa
+                        dml_enabled = True
+                        log_cb("DirectML backend available.")
+                    except Exception:
+                        dml_enabled = False
+                        log_cb("DirectML import failed after install; staying on CPU.")
+                else:
+                    log_cb("DirectML install failed; staying on CPU.")
+
+        return True, None
+    except Exception as e:
+        msg = str(e)
+        if "PyTorch C-extension check failed" in msg or "Failed to load PyTorch C extensions" in msg:
+            msg += (
+                "\n\nHints:\n"
+                " • Make sure you are not launching SAS Pro from a folder that contains a 'torch' directory.\n"
+                " • If you previously ran a local PyTorch checkout, remove it from PYTHONPATH.\n"
+                f" • To force a clean reinstall, delete: {os.path.join(str(_user_runtime_dir()), 'venv')} and click Install/Update again."
+            )
+        if "macOS arm64 on Python 3.13" in msg:
+            msg += (
+                "\n\nmacOS tip:\n"
+                " • Install Python 3.12: `brew install python@3.12`\n"
+                " • Ensure `/opt/homebrew/bin/python3.12` exists, then relaunch SAS Pro.\n"
+            )
+        return False, msg
+
+def current_backend() -> str:
+    try:
+        add_runtime_to_sys_path(status_cb=lambda *_: None)
+        import importlib
+        import platform as _plat
+        torch = importlib.import_module("torch")
+
+        if getattr(torch, "cuda", None) and torch.cuda.is_available():
+            try: name = torch.cuda.get_device_name(0)
+            except Exception: name = "CUDA"
+            return f"CUDA ({name})"
+
+        # Intel XPU (Arc / Xe)
+        if hasattr(torch, "xpu") and torch.xpu.is_available():
+            try:
+                name = None
+                if hasattr(torch.xpu, "get_device_name"):
+                    name = torch.xpu.get_device_name(0)
+            except Exception:
+                name = None
+            return f"Intel XPU{f' ({name})' if name else ''}"
+
+        cuda_tag = getattr(getattr(torch, "version", None), "cuda", None)
+        has_nv = _has_nvidia() and _plat.system() in ("Windows","Linux")
+        if cuda_tag and has_nv:
+            return f"CPU (CUDA {cuda_tag} not available — check NVIDIA driver/CUDA runtime)"
+
+        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            return "Apple MPS"
+
+        if _plat.system() == "Windows" and not has_nv:
+            try:
+                import torch_directml  # noqa
+                return "DirectML"
+            except Exception:
+                pass
+
+        return "CPU"
+    except Exception:
+        return "Not installed"

setiastro/saspro/accel_workers.py

@@ -0,0 +1,30 @@
+# pro/accel_workers.py
+from __future__ import annotations
+from PyQt6.QtCore import QObject, pyqtSignal, QThread
+from setiastro.saspro.accel_installer import ensure_torch_installed
+
+class AccelInstallWorker(QObject):
+    progress = pyqtSignal(str)        # emitted from worker thread; GUI updates must connect with QueuedConnection
+    finished = pyqtSignal(bool, str)  # (ok, message)
+
+    def __init__(self, prefer_gpu: bool = True):
+        super().__init__()
+        self.prefer_gpu = prefer_gpu
+
+    def _log(self, s: str):
+        # Never touch widgets here; just emit text
+        self.progress.emit(s)
+
+    def run(self):
+        # pure backend work; no QWidget/QMessageBox etc. in this method
+        ok, msg = ensure_torch_installed(self.prefer_gpu, self._log)
+
+        # honor cancellation if requested
+        if QThread.currentThread().isInterruptionRequested():
+            self.finished.emit(False, "Canceled.")
+            return
+
+        if ok:
+            self.finished.emit(True, "PyTorch installed and ready.")
+        else:
+            self.finished.emit(False, msg or "Installation failed.")