504 lines
23 KiB
Python
504 lines
23 KiB
Python
"""Embed the browser UI inside the AppWindow without duplicating any rendering.
|
|
|
|
The desktop already owns the hardware and draws every plot with pyqtgraph, so the
|
|
web view simply streams a snapshot of the *current Qt plot widget* — the browser
|
|
shows exactly what the desktop shows, for every processing mode, with zero
|
|
re-implemented rendering. Controls cross back to the Qt main thread through queued
|
|
signals (the GPIO-button pattern) and invoke the AppWindow's existing buttons.
|
|
|
|
Two roles, kept separate from the Qt-free :mod:`python_app.webui` package:
|
|
|
|
* :class:`AppWindowWebController` — the Qt bridge implementing the web contract.
|
|
* :class:`AppWindowWebMixin` — wiring that grabs the plot, refreshes snapshots,
|
|
and starts/stops the server.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import contextlib
|
|
import os
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
|
|
from PyQt6.QtCore import QBuffer, QIODevice, QObject, pyqtSignal
|
|
|
|
from python_app.gui.controllers.app_window_config.live_processing_mixin import web_apply_field_names
|
|
from python_app.webui.controller import WebActionError
|
|
|
|
_WEBUI_PORT_ENV = "RADAR_SYSTEM_WEBUI_PORT"
|
|
_DEFAULT_PORT = 8080
|
|
# Upper bound on how long a browser control call waits for the GUI thread to run and
|
|
# report the action. Comfortably above a real save/start, but bounded so a wedged GUI
|
|
# thread surfaces as an error instead of hanging the HTTP worker forever.
|
|
_WEB_ACTION_TIMEOUT_S = 30.0
|
|
|
|
|
|
class _WebActionCall:
|
|
"""One synchronous web action: the GUI thread fills the result, the web thread waits.
|
|
|
|
The web (uvicorn) thread emits a control signal carrying this object and blocks on
|
|
:attr:`done`; the GUI thread runs the desktop action, records any surfaced error in
|
|
:attr:`error`, and sets the event. This turns the fire-and-forget signal bridge into
|
|
a request/response so failures reach the browser.
|
|
"""
|
|
|
|
__slots__ = ("done", "error", "_lock", "_started")
|
|
|
|
def __init__(self) -> None:
|
|
self.done = threading.Event()
|
|
self.error: str | None = None
|
|
self._lock = threading.Lock()
|
|
self._started = False
|
|
|
|
def begin(self) -> bool:
|
|
with self._lock:
|
|
if self.done.is_set() or self._started:
|
|
return False
|
|
self._started = True
|
|
return True
|
|
|
|
def finish(self, error: str | None = None) -> None:
|
|
with self._lock:
|
|
if not self.done.is_set():
|
|
self.error = error
|
|
self.done.set()
|
|
|
|
def cancel(self, error: str, *, queued_only: bool = True) -> bool:
|
|
with self._lock:
|
|
if self.done.is_set():
|
|
return True
|
|
if queued_only and self._started:
|
|
return False
|
|
self.error = error
|
|
self.done.set()
|
|
return True
|
|
# Headless has no shown window, so give the offscreen window a usable size for the
|
|
# grabbed plot. In GUI mode the user's real (shown) window size is used as-is.
|
|
_HEADLESS_PLOT_SIZE = (1600, 900)
|
|
# Grab/encode the plot at most this often (the plot only changes per result/redraw).
|
|
_GRAB_INTERVAL_S = 0.2
|
|
# Field names a web client may apply: the form's live/display fields plus the
|
|
# history command. Derived from the single schema so it can never drift from the form.
|
|
_LIVE_FIELD_NAMES = web_apply_field_names()
|
|
|
|
|
|
def _safe_run_config_path(run_configs_dir: Path, name: str) -> Path | None:
|
|
"""Resolve a client-supplied config name to a file strictly inside ``run_configs_dir``.
|
|
|
|
The web sends only a bare file name; this is the trust boundary. The name must be a
|
|
plain ``.json`` file living directly in the directory — ``name != Path(name).name``
|
|
rejects any separator or ``..`` traversal. Returns the path, or ``None`` if invalid.
|
|
"""
|
|
if not name or name != Path(name).name or not name.lower().endswith(".json"):
|
|
return None
|
|
candidate = run_configs_dir / name
|
|
return candidate if candidate.is_file() else None
|
|
|
|
|
|
def _list_run_config_names(run_configs_dir: Path) -> list[str]:
|
|
"""Return the sorted ``.json`` file names directly inside ``run_configs_dir``."""
|
|
if not run_configs_dir.is_dir():
|
|
return []
|
|
return sorted(entry.name for entry in run_configs_dir.glob("*.json") if entry.is_file())
|
|
|
|
|
|
class AppWindowWebController(QObject):
|
|
"""Qt bridge satisfying the web contract: streams the plot, forwards controls.
|
|
|
|
Mutating calls (made on the web thread) emit queued signals the AppWindow
|
|
connects to its existing slots. Read calls return immutable snapshots the
|
|
AppWindow refreshes on its poll tick — replaced atomically, never mutated in
|
|
place, so the web thread reads a consistent value without locking.
|
|
"""
|
|
|
|
# Control signals carry a trailing _WebActionCall the GUI slot fills in, so the web
|
|
# thread can block on the real outcome and receive the updated state.
|
|
start_requested = pyqtSignal(object)
|
|
stop_requested = pyqtSignal(object)
|
|
remove_last_requested = pyqtSignal(object)
|
|
single_capture_requested = pyqtSignal(object)
|
|
capture_requested = pyqtSignal(object)
|
|
start_recording_requested = pyqtSignal(str, str, int, object)
|
|
load_config_requested = pyqtSignal(str, object)
|
|
save_dataset_requested = pyqtSignal(str, str, object)
|
|
select_combo_requested = pyqtSignal(int, int, object)
|
|
next_combo_requested = pyqtSignal(object)
|
|
apply_settings_requested = pyqtSignal(dict, object)
|
|
|
|
def __init__(self, run_configs_dir: Path, parent: QObject | None = None) -> None:
|
|
super().__init__(parent)
|
|
self._run_configs_dir = run_configs_dir
|
|
self._status: dict = {}
|
|
self._live_settings: list = []
|
|
self._frame: dict | None = None
|
|
self._pending_lock = threading.Lock()
|
|
self._pending_calls: set[_WebActionCall] = set()
|
|
self._closed = False
|
|
|
|
# -- Snapshot refresh (Qt main thread) -----------------------------------
|
|
|
|
def update_snapshot(self, *, status: dict, live_settings: list, frame: dict | None) -> None:
|
|
"""Replace the served snapshots; ``frame`` only when a new one was grabbed."""
|
|
self._status = status
|
|
self._live_settings = live_settings
|
|
if frame is not None:
|
|
self._frame = frame
|
|
|
|
# -- WebController reads (web thread) ------------------------------------
|
|
|
|
def status(self) -> dict:
|
|
return dict(self._status)
|
|
|
|
def current_live_settings(self) -> list:
|
|
return list(self._live_settings)
|
|
|
|
def list_configs(self) -> list[str]:
|
|
"""Return the run-config file names available to load (a plain directory scan)."""
|
|
return _list_run_config_names(self._run_configs_dir)
|
|
|
|
def peek_frame(self) -> dict | None:
|
|
"""Return the most recent rendered-plot frame (or None before the first)."""
|
|
return self._frame
|
|
|
|
# -- WebController controls (web thread -> Qt main thread) ---------------
|
|
|
|
def _dispatch(self, signal, *args) -> None:
|
|
"""Emit a control signal and block until the GUI thread reports the outcome.
|
|
|
|
Runs on the web worker thread (the routes call this via a thread pool, so the
|
|
event loop is never blocked). Raises :class:`WebActionError` if the desktop
|
|
action surfaced an error or did not finish within the timeout.
|
|
"""
|
|
call = _WebActionCall()
|
|
with self._pending_lock:
|
|
if self._closed:
|
|
raise WebActionError("The application is closing")
|
|
self._pending_calls.add(call)
|
|
try:
|
|
signal.emit(*args, call)
|
|
if not call.done.wait(_WEB_ACTION_TIMEOUT_S):
|
|
if not call.cancel("The desktop did not start the action in time; the request was cancelled"):
|
|
raise WebActionError("The desktop action is still running; check its status before retrying")
|
|
if call.error is not None:
|
|
raise WebActionError(call.error)
|
|
finally:
|
|
with self._pending_lock:
|
|
self._pending_calls.discard(call)
|
|
|
|
def shutdown(self) -> None:
|
|
"""Release waiting HTTP workers and reject queued controls during teardown."""
|
|
with self._pending_lock:
|
|
self._closed = True
|
|
pending = tuple(self._pending_calls)
|
|
for call in pending:
|
|
call.cancel("The application is closing", queued_only=False)
|
|
|
|
def start(self) -> None:
|
|
self._dispatch(self.start_requested)
|
|
|
|
def stop(self) -> None:
|
|
self._dispatch(self.stop_requested)
|
|
|
|
def single_capture(self) -> None:
|
|
self._dispatch(self.single_capture_requested)
|
|
|
|
def capture_tmp_reference(self) -> None:
|
|
self._dispatch(self.capture_requested)
|
|
|
|
def remove_last_measurement(self) -> None:
|
|
self._dispatch(self.remove_last_requested)
|
|
|
|
def start_recording(self, path: str, name: str, count: int) -> None:
|
|
"""Arm a run + disk recording of the next ``count`` measurements (the desktop button)."""
|
|
if type(count) is not int or count < 1:
|
|
raise ValueError("Recording count must be a positive integer")
|
|
self._dispatch(self.start_recording_requested, path, name, count)
|
|
|
|
def apply_live_settings(self, fields: dict) -> list:
|
|
unknown = set(fields) - _LIVE_FIELD_NAMES
|
|
if unknown:
|
|
raise ValueError(f"Unknown live-settings fields: {', '.join(sorted(unknown))}")
|
|
self._dispatch(self.apply_settings_requested, dict(fields))
|
|
return self.current_live_settings()
|
|
|
|
def load_config(self, name: str) -> None:
|
|
"""Request loading the run-config named ``name`` (the desktop "Load Config" action).
|
|
|
|
Validates the name against the directory here — on the web thread — so an invalid
|
|
or unsafe name fails the HTTP request immediately; the load itself then runs
|
|
synchronously on the Qt side and any load error is surfaced too.
|
|
"""
|
|
if _safe_run_config_path(self._run_configs_dir, name) is None:
|
|
raise ValueError(f"Unknown run config: {name}")
|
|
self._dispatch(self.load_config_requested, name)
|
|
|
|
def save_dataset(self, path: str, name: str) -> None:
|
|
"""Save the last 1000 runtime measurements to ``path``/``name``."""
|
|
self._dispatch(self.save_dataset_requested, path, name)
|
|
|
|
def select_combo(self, input_pos: int, output_pos: int) -> None:
|
|
"""Select the matrix B-scan channel through the desktop display controls."""
|
|
if any(type(pos) is not int or pos < 0 for pos in (input_pos, output_pos)):
|
|
raise ValueError("Channel positions must be nonnegative integers")
|
|
self._dispatch(self.select_combo_requested, input_pos, output_pos)
|
|
|
|
def next_combo(self) -> None:
|
|
"""Advance the matrix B-scan display to the next configured channel pair."""
|
|
self._dispatch(self.next_combo_requested)
|
|
|
|
|
|
class AppWindowWebMixin:
|
|
"""Start/stop the embedded web server and feed it the live plot + settings."""
|
|
|
|
def _init_web_ui(self) -> None:
|
|
"""Start the web server (default-on, both modes), wired to existing buttons."""
|
|
self._web_controller: AppWindowWebController | None = None
|
|
self._web_server = None
|
|
self._web_frame_seq = 0
|
|
self._web_last_png: str | None = None
|
|
self._web_last_grab_s = 0.0
|
|
|
|
try:
|
|
from python_app.webui.server import WebUiServer
|
|
|
|
# Headless never shows the window; size it so the grabbed plot is usable.
|
|
if self._is_truthy_env("RADAR_SYSTEM_HEADLESS"):
|
|
self.resize(*_HEADLESS_PLOT_SIZE)
|
|
|
|
# The web picker browses this directory; ensure it exists on fresh deploys.
|
|
self._run_configs_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Capture slot for errors a web-triggered action surfaces (None = no web
|
|
# action in flight). Read default-safe by `_show_error`/`_show_exception`.
|
|
self._web_action_error_capture: list[str] | None = None
|
|
|
|
controller = AppWindowWebController(self._run_configs_dir, parent=self)
|
|
# Each control signal carries a _WebActionCall the wrapper finalizes, so the
|
|
# browser learns whether the desktop action actually succeeded.
|
|
controller.start_requested.connect(
|
|
lambda call: self._run_web_action(call, self._start_run)
|
|
)
|
|
controller.stop_requested.connect(
|
|
lambda call: self._run_web_action(call, self._stop_run)
|
|
)
|
|
controller.single_capture_requested.connect(
|
|
lambda call: self._run_web_action(call, self._start_single_capture)
|
|
)
|
|
controller.capture_requested.connect(
|
|
lambda call: self._run_web_action(call, self._capture_tmp_reference)
|
|
)
|
|
controller.remove_last_requested.connect(
|
|
lambda call: self._run_web_action(call, self._remove_last_runtime_history)
|
|
)
|
|
controller.start_recording_requested.connect(
|
|
lambda path, name, count, call: self._run_web_action(
|
|
call, self._start_web_recording, path, name, count
|
|
)
|
|
)
|
|
controller.load_config_requested.connect(
|
|
lambda name, call: self._run_web_action(call, self._load_web_config, name)
|
|
)
|
|
controller.save_dataset_requested.connect(
|
|
lambda path, name, call: self._run_web_action(call, self._save_web_dataset, path, name)
|
|
)
|
|
controller.select_combo_requested.connect(
|
|
lambda inp, out, call: self._run_web_action(call, self._select_display_combo, inp, out)
|
|
)
|
|
controller.next_combo_requested.connect(
|
|
lambda call: self._run_web_action(call, self._select_next_combo)
|
|
)
|
|
controller.apply_settings_requested.connect(
|
|
lambda fields, call: self._run_web_action(call, self._apply_web_live_settings, fields)
|
|
)
|
|
|
|
self._web_controller = controller
|
|
self._web_update_snapshot() # seed snapshots before the first request
|
|
|
|
port = self._web_ui_port()
|
|
self._web_server = WebUiServer(controller, port=port)
|
|
self._web_server.start()
|
|
self._log(f"Web UI started on http://0.0.0.0:{port}")
|
|
except Exception as exc: # noqa: BLE001 - a missing dependency must not abort startup
|
|
self._log_exception("Failed to start web UI", exc, level="WARN")
|
|
self._web_controller = None
|
|
self._web_server = None
|
|
|
|
def _run_web_action(self, call: _WebActionCall, action, *args) -> None:
|
|
"""Run a web-triggered desktop action on the GUI thread, capturing its outcome.
|
|
|
|
Errors the action reports through ``_show_error``/``_show_exception`` are
|
|
captured into the call (and still logged/shown on the desktop) instead of
|
|
vanishing from the browser's view. Re-entrancy-safe: a nested action — e.g. a
|
|
modal error dialog pumping the event loop in GUI mode — saves and restores the
|
|
capture slot, so each action only sees its own first error.
|
|
"""
|
|
if getattr(self, "_closing", False):
|
|
call.cancel("The application is closing", queued_only=False)
|
|
return
|
|
if not call.begin():
|
|
return
|
|
previous_capture = self._web_action_error_capture
|
|
capture: list[str] = []
|
|
self._web_action_error_capture = capture
|
|
error = None
|
|
try:
|
|
action(*args)
|
|
error = capture[0] if capture else None
|
|
self._web_update_snapshot()
|
|
except Exception as exc: # noqa: BLE001 - handlers self-report; this is a backstop
|
|
error = self._exception_summary(exc)
|
|
finally:
|
|
self._web_action_error_capture = previous_capture
|
|
call.finish(error)
|
|
|
|
def _load_web_config(self, name: str) -> None:
|
|
"""Load a run config chosen in the browser through the shared desktop load path.
|
|
|
|
Runs on the Qt main thread (queued from the web thread). The name is re-resolved
|
|
against the directory here as the authoritative trust boundary before any file
|
|
access, then handed to the same loader the desktop "Load Config" button uses.
|
|
"""
|
|
config_path = _safe_run_config_path(self._run_configs_dir, name)
|
|
if config_path is None:
|
|
raise ValueError(f"Unknown run config: {name}")
|
|
self._load_config_from_path(config_path)
|
|
|
|
def _save_web_dataset(self, path: str, name: str) -> None:
|
|
"""Save the last 1000 measurements via the shared desktop handler.
|
|
|
|
The web fields are remote editors of the shared save-path/name widgets: the name
|
|
is mirrored as-is (blank is valid — it yields a timestamped file), while a blank
|
|
path is ignored to avoid wiping the configured destination. The save itself — and
|
|
the radar-config filename prefix — is the unchanged desktop action.
|
|
"""
|
|
if path.strip():
|
|
self._save_path_input.setText(path)
|
|
self._save_name_input.setText(name)
|
|
self._save_snapshot()
|
|
|
|
def _start_web_recording(self, path: str, name: str, count: int) -> None:
|
|
"""Arm disk recording from the browser via the same handler as the desktop button.
|
|
|
|
The save path/name fields are mirrored exactly like ``_save_web_dataset`` (blank
|
|
path keeps the configured destination), the record count is applied to the shared
|
|
spinbox, then the unchanged desktop arming action runs.
|
|
"""
|
|
if type(count) is not int or not self._record_count.minimum() <= count <= self._record_count.maximum():
|
|
raise ValueError(
|
|
f"Recording count must be an integer from {self._record_count.minimum()} "
|
|
f"to {self._record_count.maximum()}"
|
|
)
|
|
if path.strip():
|
|
self._save_path_input.setText(path)
|
|
self._save_name_input.setText(name)
|
|
self._record_count.setValue(count)
|
|
self._start_run_with_recording()
|
|
|
|
def _web_update_snapshot(self) -> None:
|
|
"""Refresh the snapshots the bridge serves (called on the Qt poll tick).
|
|
|
|
Must NEVER raise: it runs inside the periodic render tick, where an escaping
|
|
exception would abort the Qt slot (qFatal) and kill the app.
|
|
"""
|
|
controller = getattr(self, "_web_controller", None)
|
|
if controller is None:
|
|
return
|
|
try:
|
|
controller.update_snapshot(
|
|
status={
|
|
"running": self._supervisor.is_running(),
|
|
"processor_running": self._supervisor.is_processor_running(),
|
|
"ring_name": self._defaults_config.rings.results.name,
|
|
# File name of the currently loaded config profile, so the web picker
|
|
# can show what is active (the desktop tracks the full path).
|
|
"active_config": self._active_profile_path.name,
|
|
# Current save path/name, so the web fields can prefill the desktop values.
|
|
"save_path": self._save_path_input.text(),
|
|
"save_name": self._save_name_input.text(),
|
|
# Default record count + live disk-recording progress for the web UI.
|
|
"record_count": int(self._record_count.value()),
|
|
"recording": self._recording_status(),
|
|
# Per-stage capture counts, identical to the desktop history
|
|
# label (raw -> preprocessed -> results), mirrored to the browser.
|
|
"raw_count": len(self._raw_history),
|
|
"preprocessed_count": len(self._pre_history),
|
|
"result_count": len(self._result_history),
|
|
"sar3d_status": self._sar3d_status_label.text()
|
|
if self._processing_mode.currentText() == "sar3d" else "",
|
|
"display_combo": {
|
|
"enabled": self._is_matrix_radar_model_selected()
|
|
and self._processing_mode.currentText() == "bscan",
|
|
"input": self._single_combo_input.text(),
|
|
"output": self._single_combo_output.text(),
|
|
"options": self._available_display_combo_keys()
|
|
if self._is_matrix_radar_model_selected() else [],
|
|
},
|
|
},
|
|
live_settings=self._web_settings_schema(),
|
|
frame=self._web_grab_frame_if_due(),
|
|
)
|
|
except Exception as exc: # noqa: BLE001 - the render loop must survive this
|
|
self._web_snapshot_errors = getattr(self, "_web_snapshot_errors", 0) + 1
|
|
if self._web_snapshot_errors % 200 == 1:
|
|
self._log_exception("Web UI snapshot refresh failed", exc, level="WARN")
|
|
|
|
def _web_grab_frame_if_due(self) -> dict | None:
|
|
"""Grab the current plot as a PNG frame, throttled and change-gated."""
|
|
now = time.monotonic()
|
|
if now - self._web_last_grab_s < _GRAB_INTERVAL_S:
|
|
return None
|
|
self._web_last_grab_s = now
|
|
png_b64 = self._grab_plot_png_b64()
|
|
if png_b64 is None or png_b64 == self._web_last_png:
|
|
return None # nothing rendered yet, or the plot is unchanged
|
|
self._web_last_png = png_b64
|
|
self._web_frame_seq += 1
|
|
return {
|
|
"type": "frame",
|
|
"seq": self._web_frame_seq,
|
|
"mode": self._processing_mode.currentText(),
|
|
"png_b64": png_b64,
|
|
}
|
|
|
|
def _grab_plot_png_b64(self) -> str | None:
|
|
"""Render the active plots; SAR3D status is sent separately as web text."""
|
|
widget = self._plot_stack.currentWidget()
|
|
if widget is self._sar3d_plots_container:
|
|
widget = self._sar3d_plot_grid
|
|
if widget is None or widget.width() <= 0 or widget.height() <= 0:
|
|
return None
|
|
pixmap = widget.grab()
|
|
if pixmap.isNull():
|
|
return None
|
|
buffer = QBuffer()
|
|
buffer.open(QIODevice.OpenModeFlag.WriteOnly)
|
|
pixmap.save(buffer, "PNG")
|
|
return base64.b64encode(bytes(buffer.data())).decode()
|
|
|
|
def _shutdown_web_ui(self) -> None:
|
|
"""Stop the server (and its broadcaster) during teardown."""
|
|
controller = getattr(self, "_web_controller", None)
|
|
if controller is not None:
|
|
controller.shutdown()
|
|
server = getattr(self, "_web_server", None)
|
|
if server is not None:
|
|
with contextlib.suppress(Exception):
|
|
server.stop()
|
|
self._web_server = None
|
|
self._log("Web UI stopped.")
|
|
self._web_controller = None
|
|
|
|
@staticmethod
|
|
def _web_ui_port() -> int:
|
|
"""Resolve the web UI port from the environment, defaulting to 8080."""
|
|
raw = os.environ.get(_WEBUI_PORT_ENV, "").strip()
|
|
if not raw:
|
|
return _DEFAULT_PORT
|
|
try:
|
|
port = int(raw)
|
|
except ValueError:
|
|
return _DEFAULT_PORT
|
|
return port if 1 <= port <= 65535 else _DEFAULT_PORT
|