setiastrosuitepro 1.6.2.post1__py3-none-any.whl

setiastro/saspro/widgets/resource_monitor.py

@@ -0,0 +1,237 @@
+# src/setiastro/saspro/widgets/resource_monitor.py
+from __future__ import annotations
+import os
+import psutil
+from PyQt6.QtCore import Qt, QUrl, QTimer, QObject, pyqtProperty, pyqtSignal, QThread
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QFrame
+from PyQt6.QtQuickWidgets import QQuickWidget
+
+from setiastro.saspro.memory_utils import get_memory_usage_mb
+from setiastro.saspro.resources import _get_base_path
+
+class GPUWorker(QThread):
+    """Background worker to monitor GPU without blocking the UI."""
+    resultReady = pyqtSignal(float)
+
+    def __init__(self, has_nvidia: bool, parent=None):
+        super().__init__(parent)
+        self._has_nvidia = has_nvidia
+        self._last_val = 0.0
+
+    def _get_windows_gpu_load(self) -> float:
+        if os.name != 'nt':
+            return 0.0
+        try:
+            import subprocess
+            # Aggregation logic to match Task Manager:
+            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
+            # 2. Sum utilization of all processes sharing that engine.
+            # 3. Take the Maximum of these sums as the overall GPU load.
+            # Aggregation logic to match Task Manager:
+            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
+            # 2. Sum utilization of all processes sharing that engine.
+            # 3. Take the Maximum of these sums as the overall GPU load.
+            cmd = (
+                "powershell -NoProfile -ExecutionPolicy Bypass -Command \""
+                "$groups = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine -ErrorAction SilentlyContinue | "
+                "Group-Object -Property { $_.Name -replace '^pid_\\d+_', '' }; "
+                "$res_list = $groups | ForEach-Object { ($_.Group | Measure-Object -Property UtilizationPercentage -Sum).Sum }; "
+                "$max_val = ($res_list | Measure-Object -Maximum).Maximum; "
+                "if ($max_val) { [math]::Round($max_val, 1) } else { 0 }\""
+            )
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            startupinfo.wShowWindow = 0 
+            
+            out = subprocess.check_output(cmd, startupinfo=startupinfo, timeout=5.0)
+            val_str = out.decode("utf-8").strip()
+            
+            if not val_str: return 0.0
+            return float(val_str.replace(",", "."))
+        except Exception:
+            return 0.0
+
+    def _get_gpu_load(self) -> float:
+        nv_val = 0.0
+        win_val = 0.0
+        
+        # 1. Check NVIDIA (Discrete)
+        if self._has_nvidia:
+            try:
+                import subprocess
+                startupinfo = None
+                if os.name == 'nt':
+                    startupinfo = subprocess.STARTUPINFO()
+                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                    startupinfo.wShowWindow = 0 
+
+                out = subprocess.check_output(
+                    ["nvidia-smi", "--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
+                    startupinfo=startupinfo,
+                    timeout=0.6
+                )
+                line = out.decode("utf-8").strip().split('\n')[0]
+                nv_val = float(line)
+            except Exception:
+                pass 
+        
+        # 2. Check Universal (Integrated)
+        if os.name == 'nt':
+            win_val = self._get_windows_gpu_load()
+            
+        return max(nv_val, win_val)
+
+    def run(self):
+        while not self.isInterruptionRequested():
+            try:
+                val = self._get_gpu_load()
+                self.resultReady.emit(val)
+                # Sleep between measurements. 250ms as requested.
+                # Note: PowerShell queries might take longer than 250ms, 
+                # but this loop will run as fast as the hardware allows without blocking UI.
+                self.msleep(250)
+            except Exception:
+                self.msleep(1000) # Error backoff on failure
+
+class ResourceBackend(QObject):
+    """Backend logic for the QML Resource Monitor."""
+    
+    cpuChanged = pyqtSignal()
+    ramChanged = pyqtSignal()
+    gpuChanged = pyqtSignal()
+    appRamChanged = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._cpu = 0.0
+        self._ram = 0.0
+        self._gpu = 0.0
+        self._app_ram_val = 0.0
+        self._app_ram_str = "0 MB"
+        
+        # Check if nvidia-smi is reachable once
+        has_nvidia = False
+        try:
+            import shutil
+            if shutil.which("nvidia-smi"):
+                has_nvidia = True
+        except Exception:
+            pass
+
+        # Start Background GPU Worker
+        self._gpu_worker = GPUWorker(has_nvidia, self)
+        self._gpu_worker.resultReady.connect(self._on_gpu_measured)
+        self._gpu_worker.start()
+
+        # Timer for CPU/RAM updates (250ms as requested)
+        self._timer = QTimer(self)
+        self._timer.setInterval(250) 
+        self._timer.timeout.connect(self._update_stats)
+        self._timer.start()
+
+    def _on_gpu_measured(self, val: float):
+        self._gpu = val
+        self.gpuChanged.emit()
+
+    @pyqtProperty(float, notify=cpuChanged)
+    def cpuUsage(self):
+        return self._cpu
+
+    @pyqtProperty(float, notify=ramChanged)
+    def ramUsage(self):
+        return self._ram
+
+    @pyqtProperty(float, notify=gpuChanged)
+    def gpuUsage(self):
+        return self._gpu
+
+    @pyqtProperty(str, notify=appRamChanged)
+    def appRamString(self):
+        return self._app_ram_str
+
+    def _update_stats(self):
+        # 1. CPU
+        try:
+            self._cpu = psutil.cpu_percent(interval=None)
+        except Exception:
+            self._cpu = 0.0
+        
+        # 2. System RAM
+        try:
+            vm = psutil.virtual_memory()
+            self._ram = vm.percent
+        except Exception:
+            self._ram = 0.0
+
+        # 3. App RAM
+        try:
+            mb = get_memory_usage_mb()
+            self._app_ram_val = mb
+            self._app_ram_str = f"{int(mb)} MB"
+        except Exception:
+            self._app_ram_str = "? MB"
+
+        self.cpuChanged.emit()
+        self.ramChanged.emit()
+        self.appRamChanged.emit()
+
+    def stop(self):
+        """Explicitly stop background threads."""
+        if hasattr(self, "_gpu_worker") and self._gpu_worker.isRunning():
+            self._gpu_worker.requestInterruption()
+            self._gpu_worker.quit()
+            self._gpu_worker.wait(1000)
+
+    def __del__(self):
+        self.stop()
+
+
+class SystemMonitorWidget(QQuickWidget):
+    """
+    The QQuickWidget hosting the QML content.
+    """
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        
+        self.setResizeMode(QQuickWidget.ResizeMode.SizeRootObjectToView)
+        self.setAttribute(Qt.WidgetAttribute.WA_AlwaysStackOnTop, False)
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
+        self.setClearColor(Qt.GlobalColor.transparent)
+
+        # Connect Backend
+        self.backend = ResourceBackend(self)
+        self.rootContext().setContextProperty("backend", self.backend)
+        
+        # We need to manually wire property updates because we are binding to root properties in QML
+        # Actually, simpler pattern: QML file reads from an object we inject.
+        # Let's adjust QML slightly to bind to `backend.cpuUsage` etc. if we can,
+        # OR we leave QML as having properties and we set them from Python.
+        #
+        # Better approach for Py+QML: 
+        # Inject `backend` into context, modify QML to use `backend.cpuUsage`.
+        # But since I already wrote QML with root properties, I will just set them directly 
+        # or update the QML file. Updating QML is cleaner.
+        #
+        # For now, let's keep QML independent and binding via setProperty? 
+        # No, properly: context property is best.
+        #
+        # Let's re-write the QML loading part to use a safer 'initialProperties' approach or just signal/slots.
+        #
+        # EASIEST: QML binds to `root.cpuUsage`. Python sets `root.cpuUsage`.
+        
+        self.backend.cpuChanged.connect(self._push_data_to_qml)
+        self.backend.ramChanged.connect(self._push_data_to_qml)
+        self.backend.gpuChanged.connect(self._push_data_to_qml)
+        self.backend.appRamChanged.connect(self._push_data_to_qml)
+        
+        # Load QML
+        qml_path = os.path.join(_get_base_path(), "qml", "ResourceMonitor.qml")
+        self.setSource(QUrl.fromLocalFile(qml_path))
+
+    def _push_data_to_qml(self):
+        root = self.rootObject()
+        if root:
+            root.setProperty("cpuUsage", self.backend.cpuUsage)
+            root.setProperty("ramUsage", self.backend.ramUsage)
+            root.setProperty("gpuUsage", self.backend.gpuUsage)
+            root.setProperty("appRamString", self.backend.appRamString)

setiastro/saspro/widgets/spinboxes.py

@@ -0,0 +1,275 @@
+# pro/widgets/spinboxes.py
+"""
+Custom spinbox widgets for Seti Astro Suite Pro.
+
+Provides enhanced spinbox widgets with consistent styling and behavior.
+"""
+from __future__ import annotations
+
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtWidgets import (
+    QWidget, QHBoxLayout, QVBoxLayout, QLineEdit, QToolButton
+)
+from PyQt6.QtGui import QIntValidator, QDoubleValidator
+
+
+class CustomSpinBox(QWidget):
+    """
+    A custom integer spin box widget with up/down buttons.
+    
+    Emits valueChanged(int) when the value changes.
+    
+    Usage:
+        spin = CustomSpinBox(minimum=0, maximum=100, initial=50, step=1)
+        spin.valueChanged.connect(my_handler)
+    """
+    valueChanged = pyqtSignal(int)
+
+    def __init__(
+        self,
+        minimum: int = 0,
+        maximum: int = 100,
+        initial: int = 0,
+        step: int = 1,
+        parent: QWidget | None = None
+    ):
+        super().__init__(parent)
+        self.minimum = minimum
+        self.maximum = maximum
+        self.step = step
+        self._value = initial
+
+        # Line edit for value display/entry
+        self.lineEdit = QLineEdit(str(initial))
+        self.lineEdit.setAlignment(Qt.AlignmentFlag.AlignRight)
+        self.lineEdit.setValidator(QIntValidator(self.minimum, self.maximum, self))
+        self.lineEdit.editingFinished.connect(self._on_editing_finished)
+
+        # Up/down buttons
+        self.upButton = QToolButton()
+        self.upButton.setText("▲")
+        self.upButton.setAutoRepeat(True)
+        self.upButton.setAutoRepeatInterval(50)
+        self.upButton.setAutoRepeatDelay(300)
+        self.upButton.clicked.connect(self._increase_value)
+        
+        self.downButton = QToolButton()
+        self.downButton.setText("▼")
+        self.downButton.setAutoRepeat(True)
+        self.downButton.setAutoRepeatInterval(50)
+        self.downButton.setAutoRepeatDelay(300)
+        self.downButton.clicked.connect(self._decrease_value)
+
+        # Layout buttons vertically
+        button_layout = QVBoxLayout()
+        button_layout.addWidget(self.upButton)
+        button_layout.addWidget(self.downButton)
+        button_layout.setSpacing(0)
+        button_layout.setContentsMargins(0, 0, 0, 0)
+
+        # Main horizontal layout
+        main_layout = QHBoxLayout()
+        main_layout.addWidget(self.lineEdit)
+        main_layout.addLayout(button_layout)
+        main_layout.setSpacing(0)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(main_layout)
+
+        self._update_button_states()
+
+    @property
+    def value(self) -> int:
+        """Get the current value."""
+        return self._value
+
+    def setValue(self, val: int) -> None:
+        """Set the value, clamping to min/max."""
+        val = max(self.minimum, min(self.maximum, val))
+        if val != self._value:
+            self._value = val
+            self.lineEdit.setText(str(val))
+            self.valueChanged.emit(val)
+            self._update_button_states()
+
+    def setMinimum(self, minimum: int) -> None:
+        """Set the minimum value."""
+        self.minimum = minimum
+        self.lineEdit.setValidator(QIntValidator(self.minimum, self.maximum, self))
+        if self._value < minimum:
+            self.setValue(minimum)
+        self._update_button_states()
+
+    def setMaximum(self, maximum: int) -> None:
+        """Set the maximum value."""
+        self.maximum = maximum
+        self.lineEdit.setValidator(QIntValidator(self.minimum, self.maximum, self))
+        if self._value > maximum:
+            self.setValue(maximum)
+        self._update_button_states()
+
+    def setRange(self, minimum: int, maximum: int) -> None:
+        """Set both minimum and maximum values."""
+        self.minimum = minimum
+        self.maximum = maximum
+        self.lineEdit.setValidator(QIntValidator(self.minimum, self.maximum, self))
+        self.setValue(max(minimum, min(maximum, self._value)))
+
+    def setSingleStep(self, step: int) -> None:
+        """Set the step value for up/down buttons."""
+        self.step = step
+
+    def _on_editing_finished(self) -> None:
+        """Handle manual text entry."""
+        try:
+            val = int(self.lineEdit.text())
+            self.setValue(val)
+        except ValueError:
+            self.lineEdit.setText(str(self._value))
+
+    def _increase_value(self) -> None:
+        """Increase value by step."""
+        self.setValue(self._value + self.step)
+
+    def _decrease_value(self) -> None:
+        """Decrease value by step."""
+        self.setValue(self._value - self.step)
+
+    def _update_button_states(self) -> None:
+        """Enable/disable buttons at limits."""
+        self.upButton.setEnabled(self._value < self.maximum)
+        self.downButton.setEnabled(self._value > self.minimum)
+
+
+class CustomDoubleSpinBox(QWidget):
+    """
+    A custom double (float) spin box widget with up/down buttons.
+    
+    Emits valueChanged(float) when the value changes.
+    
+    Usage:
+        spin = CustomDoubleSpinBox(minimum=0.0, maximum=1.0, initial=0.5, step=0.1, decimals=2)
+        spin.valueChanged.connect(my_handler)
+    """
+    valueChanged = pyqtSignal(float)
+
+    def __init__(
+        self,
+        minimum: float = 0.0,
+        maximum: float = 100.0,
+        initial: float = 0.0,
+        step: float = 1.0,
+        decimals: int = 2,
+        parent: QWidget | None = None
+    ):
+        super().__init__(parent)
+        self.minimum = minimum
+        self.maximum = maximum
+        self.step = step
+        self.decimals = decimals
+        self._value = initial
+
+        # Line edit for value display/entry
+        self.lineEdit = QLineEdit(f"{initial:.{decimals}f}")
+        self.lineEdit.setAlignment(Qt.AlignmentFlag.AlignRight)
+        self.lineEdit.setValidator(QDoubleValidator(self.minimum, self.maximum, decimals, self))
+        self.lineEdit.editingFinished.connect(self._on_editing_finished)
+
+        # Up/down buttons
+        self.upButton = QToolButton()
+        self.upButton.setText("▲")
+        self.upButton.setAutoRepeat(True)
+        self.upButton.setAutoRepeatInterval(50)
+        self.upButton.setAutoRepeatDelay(300)
+        self.upButton.clicked.connect(self._increase_value)
+        
+        self.downButton = QToolButton()
+        self.downButton.setText("▼")
+        self.downButton.setAutoRepeat(True)
+        self.downButton.setAutoRepeatInterval(50)
+        self.downButton.setAutoRepeatDelay(300)
+        self.downButton.clicked.connect(self._decrease_value)
+
+        # Layout buttons vertically
+        button_layout = QVBoxLayout()
+        button_layout.addWidget(self.upButton)
+        button_layout.addWidget(self.downButton)
+        button_layout.setSpacing(0)
+        button_layout.setContentsMargins(0, 0, 0, 0)
+
+        # Main horizontal layout
+        main_layout = QHBoxLayout()
+        main_layout.addWidget(self.lineEdit)
+        main_layout.addLayout(button_layout)
+        main_layout.setSpacing(0)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(main_layout)
+
+        self._update_button_states()
+
+    @property
+    def value(self) -> float:
+        """Get the current value."""
+        return self._value
+
+    def setValue(self, val: float) -> None:
+        """Set the value, clamping to min/max."""
+        val = max(self.minimum, min(self.maximum, val))
+        if abs(val - self._value) > 1e-10:
+            self._value = val
+            self.lineEdit.setText(f"{val:.{self.decimals}f}")
+            self.valueChanged.emit(val)
+            self._update_button_states()
+
+    def setMinimum(self, minimum: float) -> None:
+        """Set the minimum value."""
+        self.minimum = minimum
+        self.lineEdit.setValidator(QDoubleValidator(self.minimum, self.maximum, self.decimals, self))
+        if self._value < minimum:
+            self.setValue(minimum)
+        self._update_button_states()
+
+    def setMaximum(self, maximum: float) -> None:
+        """Set the maximum value."""
+        self.maximum = maximum
+        self.lineEdit.setValidator(QDoubleValidator(self.minimum, self.maximum, self.decimals, self))
+        if self._value > maximum:
+            self.setValue(maximum)
+        self._update_button_states()
+
+    def setRange(self, minimum: float, maximum: float) -> None:
+        """Set both minimum and maximum values."""
+        self.minimum = minimum
+        self.maximum = maximum
+        self.lineEdit.setValidator(QDoubleValidator(self.minimum, self.maximum, self.decimals, self))
+        self.setValue(max(minimum, min(maximum, self._value)))
+
+    def setSingleStep(self, step: float) -> None:
+        """Set the step value for up/down buttons."""
+        self.step = step
+
+    def setDecimals(self, decimals: int) -> None:
+        """Set the number of decimal places."""
+        self.decimals = decimals
+        self.lineEdit.setText(f"{self._value:.{decimals}f}")
+        self.lineEdit.setValidator(QDoubleValidator(self.minimum, self.maximum, decimals, self))
+
+    def _on_editing_finished(self) -> None:
+        """Handle manual text entry."""
+        try:
+            val = float(self.lineEdit.text())
+            self.setValue(val)
+        except ValueError:
+            self.lineEdit.setText(f"{self._value:.{self.decimals}f}")
+
+    def _increase_value(self) -> None:
+        """Increase value by step."""
+        self.setValue(self._value + self.step)
+
+    def _decrease_value(self) -> None:
+        """Decrease value by step."""
+        self.setValue(self._value - self.step)
+
+    def _update_button_states(self) -> None:
+        """Enable/disable buttons at limits."""
+        self.upButton.setEnabled(self._value < self.maximum - 1e-10)
+        self.downButton.setEnabled(self._value > self.minimum + 1e-10)

setiastro/saspro/widgets/themed_buttons.py

@@ -0,0 +1,13 @@
+# pro/widgets/themed_buttons.py
+from __future__ import annotations
+from PyQt6.QtGui import QIcon
+from PyQt6.QtWidgets import QToolButton
+
+def themed_toolbtn(icon_name: str, tip: str, *, on_click=None) -> QToolButton:
+    b = QToolButton()
+    b.setIcon(QIcon.fromTheme(icon_name))
+    b.setToolTip(tip)
+    b.setAutoRaise(True)  # nice flat toolbar look
+    if on_click is not None:
+        b.clicked.connect(on_click)
+    return b