matchpatch 0.4.0__py3-none-any.whl

matchpatch/gui/snapshot_header.py

@@ -0,0 +1,48 @@
+"""Two-tier header for compact snapshot columns."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QRect, QSize, Qt
+from PySide6.QtGui import QPainter, QPaintEvent, QPen
+from PySide6.QtWidgets import QHeaderView, QStyle, QStyleOptionHeader, QWidget
+
+
+class SnapshotHeader(QHeaderView):
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(Qt.Orientation.Horizontal, parent)
+        self.setSectionsClickable(True)
+        self.setMinimumHeight(48)
+
+    def sizeHint(self) -> QSize:
+        hint = super().sizeHint()
+        hint.setHeight(max(hint.height() * 2, 48))
+        return hint
+
+    def paintSection(self, painter: QPainter, rect: QRect, logical_index: int) -> None:
+        if logical_index < 3:
+            super().paintSection(painter, rect, logical_index)
+            return
+
+        lower = QRect(rect.x(), rect.y() + rect.height() // 2, rect.width(), rect.height() // 2)
+        super().paintSection(painter, lower, logical_index)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        super().paintEvent(event)
+        if self.count() <= 3:
+            return
+
+        left = self.sectionViewportPosition(3)
+        right = self.sectionViewportPosition(self.count() - 1) + self.sectionSize(self.count() - 1)
+        rect = QRect(left, 0, right - left, self.height() // 2)
+        option = QStyleOptionHeader()
+        option.rect = rect
+        option.text = "Snapshots"
+        option.textAlignment = Qt.AlignmentFlag.AlignCenter
+        painter = QPainter(self.viewport())
+        self.style().drawControl(QStyle.ControlElement.CE_Header, option, painter, self)
+        pen = QPen(self.palette().mid().color())
+        pen.setWidth(2)
+        painter.setPen(pen)
+        for logical_index in range(3, self.count(), 3):
+            x = self.sectionViewportPosition(logical_index)
+            painter.drawLine(x, self.height() // 2, x, self.height())

matchpatch/gui/worker.py

@@ -0,0 +1,135 @@
+"""Background Qt worker for the blocking normalization workflow."""
+
+from __future__ import annotations
+
+import threading
+
+from PySide6.QtCore import QObject, QThread, Signal
+
+from matchpatch.normalize import (
+    check_windows_hardware,
+    run_windows_analysis,
+    run_windows_optimization,
+)
+from matchpatch.workflow import ImportRequest, NormalizationRequest, normalize_presets
+
+
+class HardwareCheckWorker(QThread):
+    completed = Signal()
+    failed = Signal(str)
+
+    def __init__(self, request: NormalizationRequest, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self.request = request
+
+    def run(self) -> None:
+        try:
+            check_windows_hardware(self.request)
+        except Exception as exc:  # noqa: BLE001
+            self.failed.emit(str(exc))
+        else:
+            self.completed.emit()
+
+
+class NormalizationWorker(QThread):
+    progress = Signal(object)
+    import_requested = Signal(object)
+    completed = Signal(object)
+    cancelled = Signal()
+    failed = Signal(str)
+
+    def __init__(self, request: NormalizationRequest, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self.request = request
+        self._confirmation = threading.Event()
+        self._confirmation_answer = False
+        self._cancelled = False
+
+    def run(self) -> None:
+        try:
+            result = normalize_presets(
+                self.request,
+                run_analysis=lambda request, preset_ids, csv_path, callback: run_windows_analysis(
+                    request,
+                    preset_ids,
+                    csv_path,
+                    callback,
+                    lambda: self._cancelled,
+                ),
+                on_progress=self.progress.emit,
+                confirm_import=self._confirm_import,
+            )
+        except Exception as exc:  # noqa: BLE001
+            if self._cancelled:
+                self.cancelled.emit()
+            else:
+                self.failed.emit(str(exc))
+        else:
+            self.completed.emit(result)
+
+    def answer_import(self, confirmed: bool) -> None:
+        self._confirmation_answer = confirmed
+        self._confirmation.set()
+
+    def cancel(self) -> None:
+        self._cancelled = True
+        self.answer_import(False)
+
+    def _confirm_import(self, request: ImportRequest) -> bool:
+        if self._cancelled:
+            return False
+
+        self._confirmation_answer = False
+        self._confirmation.clear()
+        self.import_requested.emit(request)
+        self._confirmation.wait()
+        return self._confirmation_answer and not self._cancelled
+
+
+class MeasurementOptimizationWorker(QThread):
+    progress = Signal(object)
+    completed = Signal(str)
+    cancelled = Signal()
+    failed = Signal(str)
+
+    def __init__(
+        self,
+        request: NormalizationRequest,
+        preset_id: int,
+        stability_runs: int,
+        termination_tolerance: float,
+        stability_tolerance: float,
+        pinned_parameters: tuple[str, ...] = (),
+        parent: QObject | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self.request = request
+        self.preset_id = preset_id
+        self.stability_runs = stability_runs
+        self.termination_tolerance = termination_tolerance
+        self.stability_tolerance = stability_tolerance
+        self.pinned_parameters = pinned_parameters
+        self._cancelled = False
+
+    def run(self) -> None:
+        try:
+            result = run_windows_optimization(
+                self.request,
+                self.preset_id,
+                stability_runs=self.stability_runs,
+                termination_tolerance=self.termination_tolerance,
+                stability_tolerance=self.stability_tolerance,
+                pinned_parameters=self.pinned_parameters,
+                on_progress=self.progress.emit,
+                cancel_requested=lambda: self._cancelled,
+            )
+        except Exception as exc:  # noqa: BLE001
+            if self._cancelled:
+                self.cancelled.emit()
+            else:
+                self.failed.emit(str(exc))
+        else:
+            self.completed.emit(result)
+
+    def cancel(self) -> None:
+        self._cancelled = True