lr-shuttle 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

{lr_shuttle-0.1.0.dist-info → lr_shuttle-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.1.0
+Version: 0.1.1
 Summary: CLI and Python client for host-side of json based serial communication with embedded device bridge.
 Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
 License: MIT
@@ -80,7 +80,7 @@ make -C host dev
 
 ### Sequence Integrity Checks
 
-Every device message carries a monotonically increasing `seq` counter. Shuttle enforces sequential integrity both within multi-transfer operations and across invocations when requested:
+Every device message carries a monotonically increasing `seq` counter emitted by the firmware transport itself. Shuttle enforces sequential integrity both within multi-transfer operations and across invocations when requested:
 
 - During a command, any gap in response/event sequence numbers raises a `ShuttleSerialError`, helping you catch dropped frames immediately.
 - Pass `--seq-meta /path/to/seq.meta` to persist the last observed sequence number. Subsequent Shuttle runs expect the very next `seq` value; if a gap is detected (for example because the device dropped messages while Shuttle was offline), the CLI exits with an error detailing the missing value.

lr_shuttle-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+shuttle/cli.py,sha256=UvaRuBKVdM0JsGC-Gqh8tYauMslouAlF6QuZTXGHjTM,68046
+shuttle/constants.py,sha256=GUlAg3iEuPxLQ2mDCvlv5gVXHnlawl_YeLtaUSqsnPM,757
+shuttle/prodtest.py,sha256=V0wkbicAb-kqMPKsvvi7lQgcPvto7M8RbACU9pf7y8I,3595
+shuttle/serial_client.py,sha256=B4ci-Ox-ig65H0xO32FgJHfTG0Ievg6VjGfQ_PSZjWE,17104
+shuttle/timo.py,sha256=1K18y0QtDF2lw2Abeok9PgrpPUiCEbQdGQXOQik75Hw,16481
+lr_shuttle-0.1.1.dist-info/METADATA,sha256=HYaly9JaR-hKo_S_SzPzJc0LgCoLkh4o-Mar-oRvxlE,12040
+lr_shuttle-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lr_shuttle-0.1.1.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
+lr_shuttle-0.1.1.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
+lr_shuttle-0.1.1.dist-info/RECORD,,

shuttle/cli.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 import string
 import sys
+import time
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple
 
 import atexit
+from concurrent.futures import TimeoutError as FutureTimeout
 import typer
 from rich.console import Console
 from rich.panel import Panel
@@ -40,6 +42,7 @@ app.add_typer(
 )
 
 console = Console()
+UART_RX_POLL_INTERVAL = 0.25
 
 # Backwards-compatible aliases for tests and external callers
 _SerialLogger = SerialLogger
@@ -369,6 +372,74 @@ def _render_ping_response(response: Dict[str, Any]) -> None:
     _render_payload_response("ping", response)
 
 
+def _render_uart_event(event: Dict[str, Any]) -> None:
+    data_hex = event.get("data")
+    if not isinstance(data_hex, str):
+        console.print("[yellow]uart.rx event missing data payload[/]")
+        return
+    try:
+        payload = bytes.fromhex(data_hex)
+    except ValueError:
+        console.print("[red]uart.rx event payload is not valid hex[/]")
+        return
+
+    seq = event.get("seq", "?")
+    port = event.get("port", 0)
+    n_field = event.get("n")
+    byte_count = n_field if isinstance(n_field, int) else len(payload)
+    preview_limit = 64
+    ascii_preview = "".join(
+        chr(b) if 32 <= b < 127 else "." for b in payload[:preview_limit]
+    )
+    if len(payload) > preview_limit:
+        ascii_preview += " ..."
+
+    console.print(f"[green]uart.rx[/] seq={seq} port={port} bytes={byte_count}")
+    console.print(f"  hex  : {_format_hex(data_hex)}")
+    if payload:
+        console.print(
+            f"  ascii: {ascii_preview if ascii_preview else '(non-printable)'}"
+        )
+
+
+def _consume_uart_events(
+    listener,
+    *,
+    duration: Optional[float],
+    forever: bool,
+) -> int:
+    events_seen = 0
+    start = time.monotonic()
+    deadline = start + duration if duration is not None else None
+
+    while True:
+        if deadline is not None:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            timeout_value = (
+                remaining
+                if remaining < UART_RX_POLL_INTERVAL
+                else UART_RX_POLL_INTERVAL
+            )
+        elif forever:
+            timeout_value = UART_RX_POLL_INTERVAL
+        else:
+            timeout_value = None
+
+        try:
+            event = listener.next(timeout=timeout_value)
+        except FutureTimeout:
+            continue
+
+        _render_uart_event(event)
+        events_seen += 1
+        if duration is None and not forever:
+            break
+
+    return events_seen
+
+
 @app.callback()
 def main(
     ctx: typer.Context,
@@ -1671,6 +1742,69 @@ def uart_cfg_command(
     _render_payload_response("uart.cfg", response)
 
 
+@app.command("uart-sub")
+def uart_sub_command(
+    ctx: typer.Context,
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyUSB0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+    enable: Optional[bool] = typer.Option(
+        None,
+        "--enable/--disable",
+        help="Enable or disable uart.rx event emission",
+    ),
+    gap_ms: Optional[int] = typer.Option(
+        None,
+        "--gap-ms",
+        min=0,
+        max=1000,
+        help="Milliseconds of idle before emitting buffered bytes",
+    ),
+    buf: Optional[int] = typer.Option(
+        None,
+        "--buf",
+        min=1,
+        max=1024,
+        help="Emit an event once this many bytes are buffered",
+    ),
+):
+    """Query or update uart.rx subscription settings."""
+
+    resources = _ctx_resources(ctx)
+    sub_payload: Dict[str, Any] = {}
+    if enable is not None:
+        sub_payload["enable"] = enable
+    if gap_ms is not None:
+        sub_payload["gap_ms"] = gap_ms
+    if buf is not None:
+        sub_payload["buf"] = buf
+
+    resolved_port = _require_port(port)
+    action = "Updating" if sub_payload else "Querying"
+    with spinner(f"{action} uart.sub over {resolved_port}"):
+        try:
+            with NDJSONSerialClient(
+                resolved_port,
+                baudrate=baudrate,
+                timeout=timeout,
+                logger=resources.get("logger"),
+                seq_tracker=resources.get("seq_tracker"),
+            ) as client:
+                response = client.uart_sub(sub_payload if sub_payload else None)
+        except ShuttleSerialError as exc:
+            console.print(f"[red]{exc}[/]")
+            raise typer.Exit(1) from exc
+
+    _render_payload_response("uart.sub", response)
+
+
 @app.command("uart-tx")
 def uart_tx_command(
     ctx: typer.Context,
@@ -1754,6 +1888,93 @@ def uart_tx_command(
     _render_payload_response("uart.tx", response)
 
 
+@app.command("uart-rx")
+def uart_rx_command(
+    ctx: typer.Context,
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyUSB0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+    duration: Optional[float] = typer.Option(
+        None,
+        "--duration",
+        min=0.0,
+        help="Listen for uart.rx events for N seconds before exiting",
+    ),
+    forever: bool = typer.Option(
+        False,
+        "--forever",
+        help="Stream uart.rx events until interrupted",
+    ),
+    ensure_subscription: bool = typer.Option(
+        True,
+        "--ensure-subscription/--no-ensure-subscription",
+        help="Call uart.sub --enable before listening",
+    ),
+    gap_ms: Optional[int] = typer.Option(
+        None,
+        "--gap-ms",
+        min=0,
+        max=1000,
+        help="Override gap_ms while ensuring the subscription",
+    ),
+    buf: Optional[int] = typer.Option(
+        None,
+        "--buf",
+        min=1,
+        max=1024,
+        help="Override buf while ensuring the subscription",
+    ),
+):
+    """Stream uart.rx events emitted by the firmware."""
+
+    if forever and duration is not None:
+        raise typer.BadParameter("--duration cannot be combined with --forever")
+
+    if (gap_ms is not None or buf is not None) and not ensure_subscription:
+        raise typer.BadParameter("--gap-ms/--buf require --ensure-subscription")
+
+    resources = _ctx_resources(ctx)
+    resolved_port = _require_port(port)
+    console.print(f"Listening for uart.rx events on {resolved_port}...")
+
+    events_seen = 0
+    try:
+        with NDJSONSerialClient(
+            resolved_port,
+            baudrate=baudrate,
+            timeout=timeout,
+            logger=resources.get("logger"),
+            seq_tracker=resources.get("seq_tracker"),
+        ) as client:
+            if ensure_subscription:
+                sub_payload: Dict[str, Any] = {"enable": True}
+                if gap_ms is not None:
+                    sub_payload["gap_ms"] = gap_ms
+                if buf is not None:
+                    sub_payload["buf"] = buf
+                client.uart_sub(sub_payload)
+            listener = client.register_event_listener("uart.rx")
+            events_seen = _consume_uart_events(
+                listener, duration=duration, forever=forever
+            )
+    except ShuttleSerialError as exc:
+        console.print(f"[red]{exc}[/]")
+        raise typer.Exit(1) from exc
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted by user[/]")
+        raise typer.Exit(1)
+
+    if not events_seen:
+        console.print("[yellow]No uart.rx events observed[/]")
+
+
 @app.command("get-info")
 def get_info(
     ctx: typer.Context,

shuttle/serial_client.py

@@ -342,6 +342,12 @@ class NDJSONSerialClient:
             payload["port"] = port
         return self._command("uart.tx", payload)
 
+    def uart_sub(self, sub: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {}
+        if sub:
+            payload["uart"] = {"sub": sub}
+        return self._command("uart.sub", payload)
+
     def _command(self, op: str, params: Dict[str, Any]) -> Dict[str, Any]:
         future = self.send_command(op, params)
         return future.result()

lr_shuttle-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-shuttle/cli.py,sha256=KKNThf4eG6oOmqR__tw6Yqx-Y62epztbKje3WfNWGy0,61201
-shuttle/constants.py,sha256=GUlAg3iEuPxLQ2mDCvlv5gVXHnlawl_YeLtaUSqsnPM,757
-shuttle/prodtest.py,sha256=V0wkbicAb-kqMPKsvvi7lQgcPvto7M8RbACU9pf7y8I,3595
-shuttle/serial_client.py,sha256=YdZFM13KrOKHGjqW0R25jdfaf4i_O1OtaPDSzVWm5c8,16877
-shuttle/timo.py,sha256=1K18y0QtDF2lw2Abeok9PgrpPUiCEbQdGQXOQik75Hw,16481
-lr_shuttle-0.1.0.dist-info/METADATA,sha256=TvjPypziHRV3HhEwQXJOMRFgBr8fWm4C5FmDGYcSuC8,11999
-lr_shuttle-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lr_shuttle-0.1.0.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
-lr_shuttle-0.1.0.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
-lr_shuttle-0.1.0.dist-info/RECORD,,