rtint-gui 0.0.1__py3-none-any.whl

rtint_gui/__init__.py

@@ -0,0 +1,8 @@
+"""rtint-gui — desktop GUI for the rtint real-time target interface."""
+
+try:
+    # Populated by setuptools-scm at build/install time (see pyproject.toml's
+    # [tool.setuptools_scm].version_file); matches the most recent git tag.
+    from rtint_gui._version import __version__
+except ImportError:  # pragma: no cover - dev checkout without a build
+    __version__ = "0.0.1"

rtint_gui/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

rtint_gui/app.py

@@ -0,0 +1,116 @@
+"""Application entry point.
+
+``rtint-gui`` console script: connect to a real-time target (optionally via
+``--server host:port``) and show the main window.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QApplication, QMessageBox
+
+from rtint_gui import __version__
+from rtint_gui.connection import ConnectDialog
+from rtint_gui.main_window import MainWindow
+from rtint_gui.worker import RtintWorker, warm_rtint
+
+
+def _parse_server(server_str: str) -> tuple[str, int]:
+    if ":" not in server_str:
+        raise ValueError("expected HOST:PORT (e.g. 192.168.0.10:5000)")
+    host, port_s = server_str.rsplit(":", 1)
+    host = host.strip()
+    if not host:
+        raise ValueError("host is empty")
+    try:
+        port = int(port_s)
+    except ValueError as exc:
+        raise ValueError(f"invalid port: {port_s!r}") from exc
+    if not 1 <= port <= 65535:
+        raise ValueError("port out of range (1..65535)")
+    return host, port
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rtint-gui",
+        description=f"Desktop GUI for the rtint real-time target interface (v{__version__}).",
+    )
+    parser.add_argument(
+        "--server",
+        metavar="HOST:PORT",
+        help="real-time target server and port, e.g. 192.168.0.10:5000. "
+        "When omitted a connection dialog is shown.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    app = QApplication(sys.argv if argv is None else argv)
+    app.setApplicationName("rtint-gui")
+
+    worker = RtintWorker()
+    holder: list = []  # keep windows alive for the lifetime of the app
+    dialogs: dict = {}
+
+    def show_main_window(w: RtintWorker) -> None:
+        window = MainWindow(w)
+        window.show()
+        holder[:] = [window]
+
+    def show_connect_dialog(error_text: str | None = None) -> None:
+        dlg = ConnectDialog(
+            worker,
+            on_connected=_on_connected,
+            initial_error=error_text,
+        )
+        dialogs["connect"] = dlg
+        holder[:] = [dlg]
+        dlg.show()
+
+    def _on_connected(w: RtintWorker) -> None:
+        dlg = dialogs.get("connect")
+        if dlg is not None:
+            dlg.accept()
+        show_main_window(w)
+
+    if args.server:
+        try:
+            host, port = _parse_server(args.server)
+        except ValueError as exc:
+            QMessageBox.warning(None, "rtint-gui", f"Invalid --server value: {exc}")
+            show_connect_dialog()
+        else:
+            worker.connect_controller(
+                host,
+                port,
+                # on_done receives the new RtintController; the window needs
+                # the worker itself.
+                on_done=lambda _ctl: show_main_window(worker),
+                on_error=show_connect_dialog,
+            )
+    else:
+        show_connect_dialog()
+
+    # Constructor/connection exceptions never crash the app: the worker routes
+    # them to on_error, which falls back to the ConnectDialog.
+
+    # Defer the ~1 s rtint import until after the first dialog is painted.  It
+    # still runs on the GUI thread exactly once; connect_controller joins on it
+    # if the user clicks Connect before this fires.
+    QTimer.singleShot(0, warm_rtint)
+
+    app.aboutToQuit.connect(worker.stop)
+    exit_code = app.exec()
+    worker.wait(5000)
+    return exit_code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rtint_gui/connection.py

@@ -0,0 +1,183 @@
+"""Startup connection dialog and reconnect overlay."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QDialog,
+    QFormLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class ConnectDialog(QDialog):
+    """Modal-ish startup dialog: host / port / Connect.
+
+    Connecting runs through ``worker.connect_controller`` (non-blocking, the
+    status label shows "Connecting…").  On success the worker is handed onward
+    via the ``on_connected`` callback given by the application; on failure the
+    dialog stays open and shows the error text.
+    """
+
+    def __init__(
+        self,
+        worker,
+        on_connected=None,
+        initial_error: str | None = None,
+        parent: QWidget | None = None,
+    ):
+        super().__init__(parent)
+        self.worker = worker
+        self.on_connected = on_connected
+        self.setWindowTitle("rtint-gui — Connect to real-time target")
+        self.setMinimumWidth(420)
+
+        form = QFormLayout()
+        self.host_edit = QLineEdit(self)
+        self.host_edit.setPlaceholderText("server host, e.g. 192.168.0.10")
+        self.port_spin = QSpinBox(self)
+        self.port_spin.setRange(1, 65535)
+        self.port_spin.setValue(5000)
+        self.connect_btn = QPushButton("Connect", self)
+        self.status_label = QLabel(self)
+        self.status_label.setWordWrap(True)
+        if initial_error:
+            self._set_error(str(initial_error))
+
+        form.addRow("Server:", self.host_edit)
+        form.addRow("Port:", self.port_spin)
+        form.addRow(self.connect_btn)
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(form)
+        layout.addWidget(self.status_label)
+
+        self.connect_btn.clicked.connect(self._on_connect_clicked)
+
+    def _set_error(self, text: str) -> None:
+        self.status_label.setText(text)
+        self.status_label.setStyleSheet("color: #c62828;")
+
+    def _on_connect_clicked(self) -> None:
+        host = self.host_edit.text().strip()
+        if not host:
+            self._set_error("Please enter the real-time target host.")
+            return
+        self.connect_btn.setEnabled(False)
+        self.status_label.setStyleSheet("")
+        self.status_label.setText("Connecting…")
+        self.worker.connect_controller(
+            host,
+            self.port_spin.value(),
+            on_done=self._on_connect_ok,
+            on_error=self._on_connect_error,
+        )
+
+    def _on_connect_ok(self, controller) -> None:
+        self.connect_btn.setEnabled(True)
+        if self.on_connected is not None:
+            self.on_connected(self.worker)
+
+    def _on_connect_error(self, exc_str: str) -> None:
+        self.connect_btn.setEnabled(True)
+        self._set_error(str(exc_str))
+
+
+class ReconnectOverlay(QWidget):
+    """Semi-transparent overlay offering a Reconnect button after the
+    connection to the real-time target is lost.
+
+    ``attach_to(main_window)`` parents it to the central widget and keeps it
+    sized to the central area.  Reconnect retries the last known server/port
+    through the worker and hides on success.
+    """
+
+    closed = Signal()
+
+    def __init__(self, worker, parent: QWidget | None = None):
+        super().__init__(parent)
+        self.worker = worker
+        self._main_window = None
+        self.setObjectName("reconnect_overlay")
+        self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        self.setStyleSheet(
+            "#reconnect_overlay { background-color: rgba(35, 35, 40, 210); }"
+        )
+
+        title = QLabel("Connection lost", self)
+        title.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        title.setStyleSheet("color: white; font-size: 20px; font-weight: bold;")
+        hint = QLabel(
+            "The link to the real-time target has been interrupted.", self
+        )
+        hint.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        hint.setStyleSheet("color: #d0d0d0;")
+        self.reconnect_btn = QPushButton("Reconnect", self)
+        self.reconnect_btn.setMinimumWidth(160)
+        self.status_label = QLabel("", self)
+        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.status_label.setWordWrap(True)
+        self.status_label.setStyleSheet("color: #ffb4b4;")
+
+        layout = QVBoxLayout(self)
+        layout.addStretch(1)
+        layout.addWidget(title)
+        layout.addWidget(hint)
+        layout.addSpacing(12)
+        layout.addWidget(self.reconnect_btn, 0, Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.status_label)
+        layout.addStretch(1)
+
+        self.reconnect_btn.clicked.connect(self._on_reconnect_clicked)
+        self.hide()
+
+    def attach_to(self, main_window) -> None:
+        """Parent the overlay to the main window's central widget."""
+        self._main_window = main_window
+        self.setParent(main_window.centralWidget())
+        self.hide()
+
+    def _reposition(self) -> None:
+        if self._main_window is not None:
+            self.setGeometry(self._main_window.centralWidget().rect())
+
+    def show_overlay(self) -> None:
+        self._reposition()
+        self.raise_()
+        self.show()
+
+    def hide_overlay(self) -> None:
+        self.status_label.setText("")
+        self.reconnect_btn.setEnabled(True)
+        self.hide()
+        self.closed.emit()
+
+    def _on_reconnect_clicked(self) -> None:
+        server = self.worker.server
+        port = self.worker.port
+        if not server or not port:
+            self.reconnect_btn.setEnabled(True)
+            self.status_label.setText("No known server to reconnect to.")
+            return
+        self.reconnect_btn.setEnabled(False)
+        self.status_label.setStyleSheet("color: #d0d0d0;")
+        self.status_label.setText("Connecting…")
+        self.worker.connect_controller(
+            server,
+            port,
+            on_done=self._on_connect_ok,
+            on_error=self._on_connect_error,
+        )
+
+    def _on_connect_ok(self, controller) -> None:
+        self.hide_overlay()
+
+    def _on_connect_error(self, exc_str: str) -> None:
+        self.reconnect_btn.setEnabled(True)
+        self.status_label.setStyleSheet("color: #ffb4b4;")
+        self.status_label.setText(str(exc_str))

rtint_gui/filter_inventory.py

@@ -0,0 +1,175 @@
+"""Shared, per-program cache of the loaded-filter inventory (P1.3).
+
+PF1: the Feedback Control Design probe and the Filters page both rebuilt the
+same filter inventory (name / type / parameters, ~6 serialized target round
+trips per filter) on every ``on_show``.  This module reads it in one place and
+caches the result per program so the second page open is free.
+
+Cache contract
+    * Keyed on the controller's **program name** (``ctl.program.name``) and the
+      identity of the live ``ctl.filter._filters`` mapping.  A new program
+      misses naturally; the filter-map identity guard keeps a reloaded/rebuilt
+      controller (and lightweight test doubles) from reusing a stale entry.
+    * :func:`invalidate` must be called after ANY write to a filter.  The rtint
+      biquad coefficient setters silently rewrite ``filter_type`` to
+      ``"custom"`` (plan Risk 1), so a cached type/display would otherwise go
+      stale; every write path in the pages drops the cache.
+    * The returned entries are plain dicts (copied shallowly) so a caller can
+      mutate its own view without corrupting the cache.
+
+Entry shape::
+
+    {"name": str, "unique_name": str, "class": str,
+     "subtype": str | None, "params": dict}
+
+``class`` is the filter class type (``"Biquad"`` / ``"PID"`` / ``"Remove DC"``
+...), ``subtype`` the standard-filter preset when the library reports one, and
+``params`` the derived continuous parameters from the SAME
+``filter_parameters()`` call.  The discrete ``b``/``a`` coefficients are NOT
+read here: that would cost a second six-read pass per filter (the P0.6
+``meta.loop`` capture in :mod:`rtint_gui.loop_meta` still reads them for saving).
+
+Single-read contract
+    :func:`_read_entries` calls ``flt.filter_parameters()`` exactly ONCE per
+    filter and derives both the subtype and ``params`` from that result.  For a
+    real rtint biquad ``filter_parameters()`` itself reads ``filter_type`` plus
+    ``b0..a2`` (six round trips); reading the coefficients separately here used
+    to double the cost to twelve.
+"""
+
+from __future__ import annotations
+
+import inspect
+import threading
+
+_lock = threading.Lock()
+#: Cached program name, filter-map object and entries.  The strong reference to
+#: the filter map is deliberate: it keeps ``id``/``is`` comparisons stable and
+#: prevents a freed dict's identity from being reused by a later controller.
+_cache_program: str | None = None
+_cache_fmap: object | None = None
+_cache_entries: list[dict] | None = None
+
+
+def invalidate() -> None:
+    """Drop the cached inventory (call after any filter write / program change)."""
+    global _cache_program, _cache_fmap, _cache_entries
+    with _lock:
+        _cache_program = None
+        _cache_fmap = None
+        _cache_entries = None
+
+
+def _program_of(ctl) -> str:
+    program = getattr(ctl, "program", None) if ctl is not None else None
+    name = getattr(program, "name", None)
+    return str(name) if name else ""
+
+
+def _fmap_of(ctl):
+    fctl = getattr(ctl, "filter", None) if ctl is not None else None
+    return getattr(fctl, "_filters", None) if fctl is not None else None
+
+
+def _class_type(flt) -> str:
+    """Filter CLASS type, mirroring the Filters page ``_filter_type_name``."""
+    value = getattr(flt, "_type", None)
+    if isinstance(value, str) and value:
+        return value
+    value = getattr(flt, "type", "")
+    return str(value) if value else ""
+
+
+def _filter_parameters(flt) -> dict | None:
+    """Guarded ``flt.filter_parameters()`` -> ``{"type", "params"}`` or ``None``.
+
+    This is the ONE target read per filter.  For real rtint objects the call
+    itself reads ``filter_type`` + ``b0..a2`` (six round trips) and returns the
+    canonical subtype together with the derived continuous parameters; reading
+    either separately doubles the cost (the bug this replaces).
+    """
+    fn = getattr(flt, "filter_parameters", None)
+    if not callable(fn):
+        return None
+    try:
+        info = fn()
+    except Exception:  # noqa: BLE001 - an old/faulty library must not break us
+        return None
+    if not isinstance(info, dict):
+        return None
+    params = info.get("params")
+    if not isinstance(params, dict):
+        params = {}
+    return {"type": info.get("type"), "params": dict(params)}
+
+
+def _read_entries(fmap) -> list[dict]:
+    entries: list[dict] = []
+    for flt in (fmap or {}).values():
+        try:
+            name = getattr(flt, "name", "?")
+            unique = getattr(flt, "unique_name", "?")
+            class_type = _class_type(flt)
+            # Exactly ONE filter_parameters() call per filter: subtype AND
+            # params (coefficients) come from that single result.
+            info = _filter_parameters(flt)
+        except Exception:  # noqa: BLE001 - one bad filter must not kill the list
+            continue
+        sub = (info or {}).get("type")
+        entries.append(
+            {
+                "name": name,
+                "unique_name": unique,
+                "class": class_type,
+                "subtype": sub if isinstance(sub, str) else None,
+                "params": (info or {}).get("params") or {},
+            }
+        )
+    return entries
+
+
+def get_filter_inventory(ctl, *, refresh: bool = False) -> list[dict]:
+    """Return ``[{name, unique_name, class, subtype, b, a}, ...]`` for ``ctl``.
+
+    Cached per program + filter-map identity.  ``refresh=True`` forces a
+    re-read (used by tests / explicit reloads); an empty ``ctl``/``filter``
+    yields ``[]`` and is cached like any other result.
+    """
+    global _cache_program, _cache_fmap, _cache_entries
+    program = _program_of(ctl)
+    fmap = _fmap_of(ctl)
+    with _lock:
+        if (
+            not refresh
+            and _cache_entries is not None
+            and program == _cache_program
+            and fmap is _cache_fmap
+        ):
+            return [dict(entry) for entry in _cache_entries]
+    entries = _read_entries(fmap)
+    with _lock:
+        _cache_program = program
+        _cache_fmap = fmap
+        _cache_entries = entries
+    return [dict(entry) for entry in entries]
+
+
+# --------------------------------------------------------------------------- #
+# worker capability probe
+# --------------------------------------------------------------------------- #
+
+def worker_accepts(worker, kwarg: str) -> bool:
+    """True when ``worker.submit`` advertises ``kwarg`` explicitly.
+
+    Lets the pages use the real worker's ``on_discard`` hook while staying
+    compatible with the lightweight synchronous test doubles whose ``submit``
+    only swallows unknown keywords into ``**kwargs`` (passing ``on_discard``
+    there would forward it to the job function and fail the job).
+    """
+    submit = getattr(worker, "submit", None)
+    if not callable(submit):
+        return False
+    try:
+        return kwarg in inspect.signature(submit).parameters
+    except (TypeError, ValueError):
+        return False