lr-shuttle 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

{lr_shuttle-0.2.8.dist-info → lr_shuttle-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.8
+Version: 0.2.10
 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

{lr_shuttle-0.2.8.dist-info → lr_shuttle-0.2.10.dist-info}/RECORD

@@ -1,18 +1,18 @@
-shuttle/cli.py,sha256=fv5HfJxfg8hnyO4CCA2vwG-OfTDSygnV6MrsZwv1yD8,108548
+shuttle/cli.py,sha256=-Lb5d3dwmJ0a2pFC9vrApQPx92x4Vw68OAaab6fawp0,110024
 shuttle/constants.py,sha256=GUlAg3iEuPxLQ2mDCvlv5gVXHnlawl_YeLtaUSqsnPM,757
 shuttle/flash.py,sha256=9ph23MHL40SjKZoL38Sbd3JbykGb-ECxvzBzCIjAues,4492
 shuttle/prodtest.py,sha256=nI8k2OndhqsOv8BMtXwfcpGEdmHU7ywbIgMuW49EULU,8006
-shuttle/serial_client.py,sha256=0srdCjKHW35LQFmZM_q-A9QEtSNadJp3WpqzIAHI1zo,19743
+shuttle/serial_client.py,sha256=8VPLP2nrbXIb34pWsnuXBNJ4K82bkdy3H9QWD7n0TVk,21147
 shuttle/timo.py,sha256=SfWgiYUtPjSsUln5hgDLiYMYOt8zg1DLL5t07sgu2wY,18336
 shuttle/firmware/__init__.py,sha256=KRXyz3xJ2GIB473tCHAky3DdPIQb78gX64Qn-uu55To,120
 shuttle/firmware/esp32c5/__init__.py,sha256=U2xXnb80Wv8EJaJ6Tv9iev1mVlpoaEeqsNmjmEtxdFQ,41
 shuttle/firmware/esp32c5/boot_app0.bin,sha256=-UxdeGp6j6sGrF0Q4zvzdxGmaXY23AN1WeoZzEEKF_A,8192
-shuttle/firmware/esp32c5/devboard.ino.bin,sha256=idrwg2JFHYjLK2KQVj4d_v31GHkqO8gEgr2TWkPHbbY,1101248
+shuttle/firmware/esp32c5/devboard.ino.bin,sha256=OIGcK7ZFonpK67YaYfQLzxCPzIikrj-KfgvgeJ5jGe8,1101248
 shuttle/firmware/esp32c5/devboard.ino.bootloader.bin,sha256=LPU51SdUwebYemCZb5Pya-wGe7RC4UXrkRmBnsHePp0,20784
 shuttle/firmware/esp32c5/devboard.ino.partitions.bin,sha256=FIuVnL_xw4qo4dXAup1hLFSZe5ReVqY_QSI-72UGU6E,3072
 shuttle/firmware/esp32c5/manifest.json,sha256=CPOegfEK4PTtI6UPeohuUKkJNeg0t8aWntEczpoxYt4,480
-lr_shuttle-0.2.8.dist-info/METADATA,sha256=6yYpMjMjWpAOEMIJntX3XDiX1MveRgqJ3TnjheFZ_Ks,15574
-lr_shuttle-0.2.8.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-lr_shuttle-0.2.8.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
-lr_shuttle-0.2.8.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
-lr_shuttle-0.2.8.dist-info/RECORD,,
+lr_shuttle-0.2.10.dist-info/METADATA,sha256=iP9luZKiBfh8p52Ki419v-KB24CM54sbkjuerFim0hM,15575
+lr_shuttle-0.2.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lr_shuttle-0.2.10.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
+lr_shuttle-0.2.10.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
+lr_shuttle-0.2.10.dist-info/RECORD,,

{lr_shuttle-0.2.8.dist-info → lr_shuttle-0.2.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

shuttle/cli.py

@@ -151,6 +151,19 @@ def _handle_sys_error_event(event: Dict[str, Any]) -> None:
     console.print(f"[red]{' '.join(parts)}[/]")
 
 
+def _flush_client_input(client) -> None:
+    """Best-effort drain any unread serial noise before issuing commands."""
+
+    flush = getattr(client, "flush_input_and_log", None)
+    if flush is None:
+        return
+    try:
+        flush()
+    except Exception:
+        # Flushing is opportunistic; failures should not leak into CLI flows.
+        pass
+
+
 @contextmanager
 def _open_serial_client(
     resolved_port: str,
@@ -767,6 +780,9 @@ def _execute_timo_sequence(
                 logger=logger,
                 seq_tracker=seq_tracker,
             ) as client:
+                # Drain any pending serial noise before issuing commands, to avoid
+                # mixing stale data into NDJSON responses.
+                _flush_client_input(client)
                 for transfer in sequence:
                     response = client.spi_xfer(**transfer)
                     responses.append(response)
@@ -2634,6 +2650,7 @@ def spi_enable_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                _flush_client_input(client)
                 response = client.spi_enable()
         except ShuttleSerialError as exc:
             console.print(f"[red]{exc}[/]")
@@ -2668,6 +2685,7 @@ def spi_disable_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                _flush_client_input(client)
                 response = client.spi_disable()
         except ShuttleSerialError as exc:
             console.print(f"[red]{exc}[/]")
@@ -3138,6 +3156,7 @@ def power_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                _flush_client_input(client)
                 method = getattr(client, method_name)
                 response = method()
         except ShuttleSerialError as exc:
@@ -3171,6 +3190,11 @@ def flash_command(
         "--erase-first/--no-erase-first",
         help="Erase the entire flash before writing",
     ),
+    sleep_after_flash: float = typer.Option(
+        1.25,
+        "--sleep-after-flash",
+        help="Seconds to wait after flashing to allow device reboot",
+    ),
 ):
     """Flash the bundled firmware image to the devboard."""
 
@@ -3194,6 +3218,24 @@ def flash_command(
             console.print(f"[red]{exc}[/]")
             raise typer.Exit(1) from exc
 
+    if sleep_after_flash:
+        time.sleep(
+            sleep_after_flash
+        )  # Give the device a moment to reboot. 0.75s is sometimes too short.
+
+    # After flashing, drain/log any startup output from the device before further commands
+    logger = ctx.obj["logger"] if ctx.obj and "logger" in ctx.obj else None
+    try:
+        from .serial_client import NDJSONSerialClient
+
+        # Use a short timeout just for draining
+        with NDJSONSerialClient(
+            resolved_port, baudrate=baudrate, timeout=0.5, logger=logger
+        ) as client:
+            _flush_client_input(client)
+    except Exception:
+        pass
+
     label = str(manifest.get("label", board))
     console.print(
         f"[green]Successfully flashed {label} ({board}) over {resolved_port}[/]"

shuttle/serial_client.py

@@ -253,7 +253,7 @@ class NDJSONSerialClient:
         except AttributeError:
             # Test stubs without an open() method are already "connected"
             pass
-        self._serial.reset_input_buffer()
+        self._reset_input_buffer()
         self._lock = threading.Lock()
         self._pending: Dict[int, CommandFuture] = {}
         self._response_backlog: Dict[int, Dict[str, Any]] = {}
@@ -281,9 +281,41 @@ class NDJSONSerialClient:
         if getattr(self, "_serial", None) and self._serial.is_open:
             self._serial.close()
 
+    def _reset_input_buffer(self) -> None:
+        serial_obj = getattr(self, "_serial", None)
+        if serial_obj is None:
+            return
+        reset = getattr(serial_obj, "reset_input_buffer", None)
+        if reset is None:
+            return
+        try:
+            reset()
+        except SerialException:
+            pass
+
+    def flush_input_and_log(self):
+        """Read and log all available data from the serial buffer before sending a command."""
+        if not hasattr(self, "_serial"):
+            return
+        try:
+            while True:
+                waiting = getattr(self._serial, "in_waiting", 0)
+                if not waiting:
+                    break
+                data = self._serial.read(waiting)
+                if data:
+                    self._log_serial("RX", data)
+        except Exception:
+            pass
+        finally:
+            self._reset_input_buffer()
+
     def send_command(self, op: str, params: Dict[str, Any]) -> CommandFuture:
         """Send a command without blocking, returning a future for the response."""
 
+        # Flush and log any unread data before sending a command
+        self.flush_input_and_log()
+
         cmd_id = self._next_cmd_id()
         message: Dict[str, Any] = {"type": "cmd", "id": cmd_id, "op": op}
         message.update(params)
@@ -457,28 +489,37 @@ class NDJSONSerialClient:
         self._log_serial("TX", payload)
 
     def _read(self) -> Optional[Dict[str, Any]]:
-        try:
-            line = self._serial.readline()
-        except SerialException as exc:  # pragma: no cover - hardware specific
-            raise ShuttleSerialError(f"Serial read failed: {exc}") from exc
-        if not line:
-            return None
-        self._log_serial("RX", line)
-        stripped = line.strip()
-        if not stripped:
-            return None
-        try:
-            decoded = stripped.decode("utf-8")
-        except UnicodeDecodeError as exc:
-            raise ShuttleSerialError(f"Invalid UTF-8 from device: {exc}") from exc
-        try:
-            message = json.loads(decoded)
-        except json.JSONDecodeError as exc:
-            raise ShuttleSerialError(
-                f"Invalid JSON from device: {decoded} ({exc})"
-            ) from exc
-        self._record_sequence(message)
-        return message
+        while True:
+            try:
+                line = self._serial.readline()
+            except SerialException as exc:  # pragma: no cover - hardware specific
+                raise ShuttleSerialError(f"Serial read failed: {exc}") from exc
+            if not line:
+                return None
+            self._log_serial("RX", line)
+            stripped = line.strip()
+            if not stripped:
+                return None
+            try:
+                decoded = stripped.decode("utf-8")
+            except UnicodeDecodeError as exc:
+                self._reset_input_buffer()
+                raise ShuttleSerialError(f"Invalid UTF-8 from device: {exc}") from exc
+            trimmed = decoded.lstrip()
+            if not trimmed:
+                continue
+            if trimmed[0] not in ("{", "["):
+                self._reset_input_buffer()
+                continue
+            try:
+                message = json.loads(decoded)
+            except json.JSONDecodeError as exc:
+                self._reset_input_buffer()
+                raise ShuttleSerialError(
+                    f"Invalid JSON from device: {decoded} ({exc})"
+                ) from exc
+            self._record_sequence(message)
+            return message
 
     def _dispatch(self, message: Dict[str, Any]) -> None:
         mtype = message.get("type")