h3cx
377e6fb323
CoreConfig how has a playback mode option which can be set to reprocess or read. Setting it to reprocess means that all derived signals are reprocessed during playback, in this case the PlaybackEngine only plays back the signals whose source is set to "origin" Setting it to read means that all derived signals are playedback from the recorded buffer, this whill be the preferred mode once offline processing is set up which will allow for more complex data processing offline once a recording is completed, which would require the read playback mode as it wouldn't support realtime processing as reprocess does
341 lines
11 KiB
Python
341 lines
11 KiB
Python
from collections import deque
|
|
import logging
|
|
import select
|
|
import sys
|
|
import termios
|
|
from threading import Lock
|
|
import time
|
|
import tty
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
from typing import Iterator
|
|
from uuid import UUID, uuid4
|
|
|
|
from rich.console import Group
|
|
from rich.live import Live
|
|
from rich.panel import Panel
|
|
from rich.table import Table
|
|
from rich.text import Text
|
|
|
|
from dynalab_core import Core
|
|
from dynalab_core.config import CoreConfig
|
|
from dynalab_core.dlunit import DLUnit
|
|
from dynalab_core.errors import DynaLabError
|
|
from dynalab_core.protocols.packets.handshake import SignalDescriptor
|
|
|
|
|
|
HOST = "127.0.0.1"
|
|
PORT = 8765
|
|
DISPLAY_FREQUENCY_HZ = 5.0
|
|
LOG_HISTORY_SIZE = 1_000
|
|
VISIBLE_LOG_LINES = 20
|
|
|
|
signal_id_1: UUID = UUID("3f32cea3-d872-4c16-a0a2-54b57171aeb2")
|
|
signal_id_2: UUID = UUID("6578ac37-99d1-410c-b3f7-d049339919b2")
|
|
|
|
|
|
@contextmanager
|
|
def keyboard_input() -> Iterator[None]:
|
|
"""Read individual keys and restore the terminal settings on exit."""
|
|
if not sys.stdin.isatty():
|
|
raise RuntimeError("This example must be run in an interactive terminal")
|
|
|
|
file_descriptor = sys.stdin.fileno()
|
|
previous_settings = termios.tcgetattr(file_descriptor)
|
|
tty.setcbreak(file_descriptor)
|
|
|
|
try:
|
|
yield
|
|
finally:
|
|
termios.tcsetattr(file_descriptor, termios.TCSADRAIN, previous_settings)
|
|
|
|
|
|
class TuiLogHandler(logging.Handler):
|
|
"""Keep recent DynaLab Core log messages available to the live display."""
|
|
|
|
def __init__(self) -> None:
|
|
super().__init__()
|
|
self._entries: deque[tuple[str, str, str, str]] = deque(maxlen=LOG_HISTORY_SIZE)
|
|
self._lock = Lock()
|
|
self.setFormatter(
|
|
logging.Formatter(
|
|
"%(asctime)s %(levelname)-8s %(name)s: %(message)s",
|
|
datefmt="%H:%M:%S",
|
|
)
|
|
)
|
|
|
|
def emit(self, record: logging.LogRecord) -> None:
|
|
try:
|
|
message = record.getMessage().replace("\n", " ↳ ")
|
|
if record.exc_info is not None and record.exc_info[1] is not None:
|
|
message = f"{message} ({record.exc_info[1]})"
|
|
level = record.levelname
|
|
level_style = {
|
|
logging.DEBUG: "dim",
|
|
logging.INFO: "white",
|
|
logging.WARNING: "yellow",
|
|
logging.ERROR: "bold red",
|
|
logging.CRITICAL: "bold white on red",
|
|
}.get(record.levelno, "white")
|
|
with self._lock:
|
|
self._entries.append(
|
|
(
|
|
self.formatter.formatTime(record, datefmt="%H:%M:%S"),
|
|
level,
|
|
message,
|
|
level_style,
|
|
)
|
|
)
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
def latest(self, limit: int) -> list[tuple[str, str, str, str]]:
|
|
with self._lock:
|
|
return list(self._entries)[-limit:]
|
|
|
|
|
|
class Dashboard:
|
|
def __init__(
|
|
self, core: Core, config: CoreConfig, log_handler: TuiLogHandler
|
|
) -> None:
|
|
self.core = core
|
|
self.config = config
|
|
self.log_handler = log_handler
|
|
self.running = True
|
|
self.playback_loaded = False
|
|
self.message = "Waiting for a connector"
|
|
self.message_style = "dim"
|
|
|
|
def handle_key(self, key: str) -> None:
|
|
try:
|
|
if key.lower() == "q":
|
|
self.running = False
|
|
elif key.lower() == "r":
|
|
self.toggle_recording()
|
|
elif key.lower() == "m":
|
|
self.toggle_mode()
|
|
elif key.lower() == "l":
|
|
self.load_playback()
|
|
elif key == " ":
|
|
self.toggle_playback()
|
|
except DynaLabError as error:
|
|
self.set_message(str(error), "bold red")
|
|
|
|
def toggle_recording(self) -> None:
|
|
if self.core.get_mode() != "realtime":
|
|
self.set_message("Recording is only available in realtime mode", "yellow")
|
|
return
|
|
|
|
if self.core.get_recording_state():
|
|
self.core.stop_recording()
|
|
self.set_message("Recording stopped and prepared for playback", "green")
|
|
else:
|
|
self.core.start_recording()
|
|
self.set_message("Recording started", "bold red")
|
|
|
|
def toggle_mode(self) -> None:
|
|
if self.core.get_recording_state():
|
|
self.set_message("Stop recording before changing mode", "yellow")
|
|
return
|
|
|
|
if self.core.get_mode() == "realtime":
|
|
self.core.set_mode("playback")
|
|
self.set_message(
|
|
"Playback mode selected; press L to load a recording", "green"
|
|
)
|
|
else:
|
|
if self.core.get_playback_state():
|
|
self.core.pause()
|
|
self.core.set_mode("realtime")
|
|
self.set_message("Realtime mode selected", "green")
|
|
|
|
def load_playback(self) -> None:
|
|
if self.core.get_mode() != "playback":
|
|
self.set_message("Switch to playback mode before loading", "yellow")
|
|
return
|
|
|
|
self.core.load_playback_engine()
|
|
self.playback_loaded = True
|
|
self.set_message("Internal processing buffer loaded", "green")
|
|
|
|
def toggle_playback(self) -> None:
|
|
if self.core.get_mode() != "playback":
|
|
self.set_message("Switch to playback mode before pressing Space", "yellow")
|
|
return
|
|
|
|
if self.core.get_playback_state():
|
|
self.core.pause()
|
|
self.set_message("Playback paused", "yellow")
|
|
else:
|
|
self.core.play()
|
|
self.set_message("Playback started", "green")
|
|
|
|
def set_message(self, message: str, style: str) -> None:
|
|
self.message = message
|
|
self.message_style = style
|
|
|
|
def render(self) -> Group:
|
|
mode = self.core.get_mode()
|
|
recording = self.core.get_recording_state()
|
|
playing = self.core.get_playback_state()
|
|
|
|
status = Table.grid(expand=True)
|
|
status.add_column(ratio=1)
|
|
status.add_column(ratio=1)
|
|
status.add_column(ratio=1)
|
|
status.add_row(
|
|
Text(f"Mode: {mode.title()}", style="bold cyan"),
|
|
Text(
|
|
"Recording: ON" if recording else "Recording: OFF",
|
|
style="bold red" if recording else "dim",
|
|
),
|
|
Text(
|
|
self.playback_status(playing),
|
|
style="bold green" if playing else "dim",
|
|
),
|
|
)
|
|
|
|
values = self.core.get_all_live_values()
|
|
descriptors = sorted(
|
|
self.core.get_all_signal_descriptors(), key=lambda signal: signal.name
|
|
)
|
|
value_table = Table(expand=True, show_lines=False)
|
|
value_table.add_column("Signal", style="cyan", ratio=2)
|
|
value_table.add_column("Origin", style="dim", ratio=1)
|
|
value_table.add_column("Value", justify="right", ratio=1)
|
|
value_table.add_column("Unit", style="dim", ratio=1)
|
|
|
|
if descriptors:
|
|
for descriptor in descriptors:
|
|
value = values.get(descriptor.id)
|
|
value_table.add_row(
|
|
descriptor.name,
|
|
descriptor.origin,
|
|
f"{value: .5f}" if value is not None else "—",
|
|
descriptor.unit or "",
|
|
)
|
|
else:
|
|
value_table.add_row("Waiting for connector…", "", "—", "")
|
|
|
|
controls = Text.from_markup(
|
|
"[bold]R[/bold] Record [bold]M[/bold] Mode "
|
|
"[bold]L[/bold] Load [bold]Space[/bold] Play/Pause "
|
|
"[bold]Q[/bold] Quit"
|
|
)
|
|
log_table = Table.grid(expand=True, padding=(0, 1))
|
|
log_table.add_column(style="dim", width=8, no_wrap=True)
|
|
log_table.add_column(width=8, no_wrap=True)
|
|
log_table.add_column(ratio=1, no_wrap=True, overflow="ellipsis")
|
|
log_entries = self.log_handler.latest(VISIBLE_LOG_LINES)
|
|
if log_entries:
|
|
for timestamp, level, message, style in log_entries:
|
|
log_table.add_row(
|
|
Text(timestamp),
|
|
Text(level, style=style),
|
|
Text(message, style=style),
|
|
)
|
|
else:
|
|
log_table.add_row("", "", Text("No DynaLab Core logs yet", style="dim"))
|
|
for _ in range(VISIBLE_LOG_LINES - max(1, len(log_entries))):
|
|
log_table.add_row("", "", "")
|
|
|
|
return Group(
|
|
Panel(
|
|
status,
|
|
title="DynaLab Core",
|
|
subtitle=f"{self.config.bind_str()} · values refresh at 5 Hz",
|
|
border_style="blue",
|
|
),
|
|
Panel(value_table, title="Live values", border_style="cyan"),
|
|
Panel(Text(self.message, style=self.message_style), title="Status"),
|
|
Panel(controls, title="Hotkeys", border_style="blue"),
|
|
Panel(
|
|
log_table,
|
|
title=f"Logs · latest {VISIBLE_LOG_LINES}",
|
|
border_style="magenta",
|
|
),
|
|
)
|
|
|
|
def playback_status(self, playing: bool) -> str:
|
|
if playing:
|
|
return "Playback: PLAYING"
|
|
if self.playback_loaded:
|
|
return "Playback: LOADED"
|
|
return "Playback: NOT LOADED"
|
|
|
|
|
|
def main() -> None:
|
|
logging.basicConfig(level=logging.CRITICAL)
|
|
log_handler = TuiLogHandler()
|
|
dynalab_logger = logging.getLogger("dynalab_core")
|
|
previous_log_level = dynalab_logger.level
|
|
previous_propagation = dynalab_logger.propagate
|
|
dynalab_logger.setLevel(logging.DEBUG)
|
|
dynalab_logger.propagate = False
|
|
dynalab_logger.addHandler(log_handler)
|
|
config = CoreConfig(host=HOST, port=PORT, playback_mode="read")
|
|
core = Core(config)
|
|
processing_source = (
|
|
Path(__file__).with_name("process.py").read_text(encoding="utf-8")
|
|
)
|
|
dashboard = Dashboard(core, config, log_handler)
|
|
|
|
derive_unit = DLUnit()
|
|
derive_unit.set_manifest(
|
|
uuid4(),
|
|
[
|
|
SignalDescriptor(
|
|
id=signal_id_1,
|
|
name="Dummy signal 1",
|
|
type="number",
|
|
timeout_ms=5000,
|
|
),
|
|
SignalDescriptor(
|
|
id=signal_id_2,
|
|
name="Dummy signal 2",
|
|
type="number",
|
|
timeout_ms=5000,
|
|
),
|
|
],
|
|
SignalDescriptor(
|
|
id=uuid4(),
|
|
name="Dummy product",
|
|
type="number",
|
|
timeout_ms=5000,
|
|
origin="derived",
|
|
),
|
|
)
|
|
derive_unit.set_data(processing_source)
|
|
core.bind_derive_unit(dlunit=derive_unit, file=None)
|
|
|
|
try:
|
|
core.start()
|
|
with (
|
|
keyboard_input(),
|
|
Live(
|
|
dashboard.render(),
|
|
auto_refresh=False,
|
|
screen=False,
|
|
) as live,
|
|
):
|
|
while dashboard.running:
|
|
update_started = time.monotonic()
|
|
|
|
while select.select([sys.stdin], [], [], 0)[0]:
|
|
dashboard.handle_key(sys.stdin.read(1))
|
|
|
|
live.update(dashboard.render(), refresh=True)
|
|
elapsed = time.monotonic() - update_started
|
|
time.sleep(max(0.0, 1.0 / DISPLAY_FREQUENCY_HZ - elapsed))
|
|
except KeyboardInterrupt:
|
|
pass
|
|
finally:
|
|
core.stop()
|
|
dynalab_logger.removeHandler(log_handler)
|
|
dynalab_logger.setLevel(previous_log_level)
|
|
dynalab_logger.propagate = previous_propagation
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|