lr-shuttle 0.2.8__tar.gz → 0.2.9__tar.gz

{lr_shuttle-0.2.8 → lr_shuttle-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.8
+Version: 0.2.9
 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 → lr_shuttle-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lr-shuttle"
-version = "0.2.8"
+version = "0.2.9"
 description = "CLI and Python client for host-side of json based serial communication with embedded device bridge."
 readme = "README.md"
 requires-python = ">=3.11"

{lr_shuttle-0.2.8 → lr_shuttle-0.2.9}/src/lr_shuttle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.8
+Version: 0.2.9
 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 → lr_shuttle-0.2.9}/src/lr_shuttle.egg-info/SOURCES.txt

@@ -28,5 +28,6 @@ tests/test_flash.py
 tests/test_prodtest_edge.py
 tests/test_prodtest_helpers.py
 tests/test_serial_client.py
+tests/test_serial_client_flush.py
 tests/test_timo.py
 tests/test_timo_write.py

{lr_shuttle-0.2.8 → lr_shuttle-0.2.9}/src/shuttle/cli.py

@@ -767,6 +767,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.
+                client.flush_input_and_log()
                 for transfer in sequence:
                     response = client.spi_xfer(**transfer)
                     responses.append(response)
@@ -2634,6 +2637,7 @@ def spi_enable_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                client.flush_input_and_log()
                 response = client.spi_enable()
         except ShuttleSerialError as exc:
             console.print(f"[red]{exc}[/]")
@@ -2668,6 +2672,7 @@ def spi_disable_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                client.flush_input_and_log()
                 response = client.spi_disable()
         except ShuttleSerialError as exc:
             console.print(f"[red]{exc}[/]")
@@ -3138,6 +3143,7 @@ def power_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                client.flush_input_and_log()
                 method = getattr(client, method_name)
                 response = method()
         except ShuttleSerialError as exc:
@@ -3171,6 +3177,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 +3205,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:
+            client.flush_input_and_log()
+    except Exception:
+        pass
+
     label = str(manifest.get("label", board))
     console.print(
         f"[green]Successfully flashed {label} ({board}) over {resolved_port}[/]"

{lr_shuttle-0.2.8 → lr_shuttle-0.2.9}/src/shuttle/serial_client.py

@@ -281,9 +281,27 @@ class NDJSONSerialClient:
         if getattr(self, "_serial", None) and self._serial.is_open:
             self._serial.close()
 
+    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") or not getattr(self._serial, "in_waiting", 0):
+            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
+
     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)

{lr_shuttle-0.2.8 → lr_shuttle-0.2.9}/tests/test_cli.py

@@ -3018,6 +3018,8 @@ def test_flash_command_invokes_helper(monkeypatch, recorded_console):
             "--board",
             "esp32c5",
             "--erase-first",
+            "--sleep-after-flash",
+            "0",
         ],
     )
 

lr_shuttle-0.2.9/tests/test_flash.py

@@ -0,0 +1,269 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+from contextlib import contextmanager
+
+import pytest
+
+from shuttle import flash
+from shuttle.firmware import DEFAULT_BOARD
+
+
+def test_list_available_boards_includes_default():
+    assert DEFAULT_BOARD in flash.list_available_boards()
+
+
+def test_load_firmware_manifest_returns_segments():
+    manifest, package = flash.load_firmware_manifest("esp32c5")
+    assert manifest["segments"]
+    assert package.endswith("esp32c5")
+
+
+def test_flash_firmware_invokes_esptool(monkeypatch):
+    calls = []
+
+    def fake_run(args):
+        calls.append(args)
+
+    monkeypatch.setattr(flash, "_run_esptool", fake_run)
+
+    manifest = flash.flash_firmware(
+        port="/dev/ttyUSB0",
+        baudrate=921600,
+        board="esp32c5",
+        erase_first=True,
+    )
+
+    assert manifest["label"]
+    assert len(calls) == 2  # erase + write
+    erase_args, write_args = calls
+    assert erase_args[:4] == ["--chip", manifest["chip"], "--port", "/dev/ttyUSB0"]
+    assert "write-flash" in write_args
+    assert any("devboard.ino.bin" in arg for arg in write_args)
+
+
+def test_flash_firmware_unknown_board():
+    with pytest.raises(flash.FirmwareFlashError):
+        flash.flash_firmware(port="/dev/null", baudrate=921600, board="does-not-exist")
+
+
+def test_load_firmware_manifest_missing_file(monkeypatch, tmp_path):
+    board = "missing"
+    pkg_dir = tmp_path / "shuttle.firmware" / board
+    pkg_dir.mkdir(parents=True)
+
+    original_files = flash.resources.files
+
+    def fake_files(package):
+        if package == f"shuttle.firmware.{board}":
+            return pkg_dir
+        return original_files(package)
+
+    monkeypatch.setattr(flash.resources, "files", fake_files)
+
+    with pytest.raises(flash.FirmwareFlashError, match="manifest missing"):
+        flash.load_firmware_manifest(board)
+
+
+def test_load_firmware_manifest_corrupt(monkeypatch, tmp_path):
+    board = "corrupt"
+    pkg_dir = tmp_path / "shuttle.firmware" / board
+    pkg_dir.mkdir(parents=True)
+    (pkg_dir / "manifest.json").write_text("not-json", encoding="utf-8")
+
+    original_files = flash.resources.files
+
+    def fake_files(package):
+        if package == f"shuttle.firmware.{board}":
+            return pkg_dir
+        return original_files(package)
+
+    monkeypatch.setattr(flash.resources, "files", fake_files)
+
+    with pytest.raises(flash.FirmwareFlashError, match="Invalid manifest"):
+        flash.load_firmware_manifest(board)
+
+
+def test_load_firmware_manifest_missing_segments(monkeypatch, tmp_path):
+    board = "no-segments"
+    pkg_dir = tmp_path / "shuttle.firmware" / board
+    pkg_dir.mkdir(parents=True)
+    (pkg_dir / "manifest.json").write_text("{}", encoding="utf-8")
+
+    original_files = flash.resources.files
+
+    def fake_files(package):
+        if package == f"shuttle.firmware.{board}":
+            return pkg_dir
+        return original_files(package)
+
+    monkeypatch.setattr(flash.resources, "files", fake_files)
+
+    with pytest.raises(flash.FirmwareFlashError, match="defines no segments"):
+        flash.load_firmware_manifest(board)
+
+
+@pytest.mark.parametrize("bad_segment", [{"file": "foo.bin"}, {"offset": "0x0"}])
+def test_flash_firmware_segment_missing_fields(monkeypatch, bad_segment):
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [bad_segment],
+    }
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+
+    with pytest.raises(
+        flash.FirmwareFlashError,
+        match="Manifest segment entries require 'offset' and 'file'",
+    ):
+        flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+
+def test_flash_firmware_missing_artifact(monkeypatch):
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [{"offset": "0x0", "file": "missing.bin"}],
+    }
+    calls = []
+    tmp_pkg = Path("/nonexistent/pkg")
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+    monkeypatch.setattr(flash.resources, "files", lambda _pkg: tmp_pkg)
+    monkeypatch.setattr(
+        flash.resources,
+        "as_file",
+        lambda _traversable: (_ for _ in ()).throw(FileNotFoundError()),
+    )
+    monkeypatch.setattr(flash, "_run_esptool", lambda args: calls.append(args))
+
+    with pytest.raises(
+        flash.FirmwareFlashError, match="Missing firmware artifact: missing.bin"
+    ):
+        flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+    assert calls == []
+
+
+def test_flash_firmware_adds_flash_options(monkeypatch, tmp_path):
+    artifact = tmp_path / "fw.bin"
+    artifact.write_bytes(b"fw")
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [{"offset": "0x1000", "file": artifact.name}],
+        "flash-mode": "dout",
+        "flash-freq": "80m",
+        "flash-size": "2MB",
+    }
+    calls = []
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+    monkeypatch.setattr(flash.resources, "files", lambda _pkg: tmp_path)
+
+    @contextmanager
+    def fake_as_file(traversable):
+        yield traversable
+
+    monkeypatch.setattr(flash.resources, "as_file", fake_as_file)
+    monkeypatch.setattr(flash, "_run_esptool", lambda args: calls.append(args))
+
+    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+    assert len(calls) == 1
+    write_args = calls[0]
+    assert ["--flash-mode", "dout"] in [
+        write_args[i : i + 2] for i in range(len(write_args) - 1)
+    ]
+    assert ["--flash-freq", "80m"] in [
+        write_args[i : i + 2] for i in range(len(write_args) - 1)
+    ]
+    assert ["--flash-size", "2MB"] in [
+        write_args[i : i + 2] for i in range(len(write_args) - 1)
+    ]
+    assert str(artifact) in write_args
+
+
+def test_flash_firmware_skips_missing_flash_options(monkeypatch, tmp_path):
+    artifact = tmp_path / "fw.bin"
+    artifact.write_bytes(b"fw")
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [{"offset": "0x1000", "file": artifact.name}],
+        # no flash-mode/freq/size keys -> exercise falsy branch
+    }
+    calls = []
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+    monkeypatch.setattr(flash.resources, "files", lambda _pkg: tmp_path)
+
+    @contextmanager
+    def fake_as_file(traversable):
+        yield traversable
+
+    monkeypatch.setattr(flash.resources, "as_file", fake_as_file)
+    monkeypatch.setattr(flash, "_run_esptool", lambda args: calls.append(args))
+
+    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+    assert len(calls) == 1
+    write_args = calls[0]
+    assert all(
+        flag not in write_args
+        for flag in ("--flash-mode", "--flash-freq", "--flash-size")
+    )
+    assert str(artifact) in write_args
+
+
+def test_flash_firmware_handles_no_compress(monkeypatch):
+    calls = []
+
+    def fake_run(args):
+        calls.append(args)
+
+    manifest, package = flash.load_firmware_manifest("esp32c5")
+    custom_manifest = dict(manifest)
+    custom_manifest["compress"] = False
+
+    monkeypatch.setattr(flash, "_run_esptool", fake_run)
+    monkeypatch.setattr(
+        flash,
+        "load_firmware_manifest",
+        lambda _board: (custom_manifest, package),
+    )
+
+    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600)
+
+    assert len(calls) == 1
+    assert "--no-compress" in calls[0]
+
+
+def test_run_esptool_success_with_exit_zero(monkeypatch):
+    recorded = []
+
+    def fake_main(args):
+        recorded.append(list(args))
+        raise SystemExit(0)
+
+    monkeypatch.setattr(flash.esptool, "main", fake_main)
+
+    flash._run_esptool(["ping"])
+
+    assert recorded[0] == ["ping"]
+
+
+def test_run_esptool_failure(monkeypatch):
+    def fake_main(_args):
+        raise SystemExit(2)
+
+    monkeypatch.setattr(flash.esptool, "main", fake_main)
+
+    with pytest.raises(flash.FirmwareFlashError):
+        flash._run_esptool(["bad"])

lr_shuttle-0.2.9/tests/test_serial_client_flush.py

@@ -0,0 +1,55 @@
+import queue
+import pytest
+import shuttle.serial_client as serial_client
+
+
+class DummySerial:
+    def __init__(self, data=b"", fail=False):
+        self._data = data
+        self._fail = fail
+        self.read_calls = 0
+        self.in_waiting = len(data)
+        self.is_open = True
+
+    def read(self, n):
+        self.read_calls += 1
+        if self._fail:
+            raise Exception("fail")
+        d, self._data = self._data[:n], self._data[n:]
+        self.in_waiting = len(self._data)
+        return d
+
+    def close(self):
+        self.is_open = False
+
+
+class DummyLogger:
+    def __init__(self):
+        self.logged = []
+
+    def log(self, direction, data):
+        self.logged.append((direction, data))
+
+
+def test_flush_input_and_log_reads_and_logs(monkeypatch):
+    client = serial_client.NDJSONSerialClient.__new__(serial_client.NDJSONSerialClient)
+    logger = DummyLogger()
+    # Data in buffer
+    client._serial = DummySerial(b"abc123")
+    client._logger = logger
+    client.flush_input_and_log()
+    assert logger.logged == [("RX", b"abc123")]
+    # No data in buffer
+    client._serial = DummySerial(b"")
+    logger.logged.clear()
+    client.flush_input_and_log()
+    assert logger.logged == []
+    # Exception in read is handled
+    client._serial = DummySerial(b"abc", fail=True)
+    client.flush_input_and_log()  # Should not raise
+
+
+def test_flush_input_and_log_no_serial():
+    client = serial_client.NDJSONSerialClient.__new__(serial_client.NDJSONSerialClient)
+    client._logger = DummyLogger()
+    client.flush_input_and_log()  # Should not raise

lr_shuttle-0.2.8/tests/test_flash.py

@@ -1,92 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import pytest
-
-from shuttle import flash
-from shuttle.firmware import DEFAULT_BOARD
-
-
-def test_list_available_boards_includes_default():
-    assert DEFAULT_BOARD in flash.list_available_boards()
-
-
-def test_load_firmware_manifest_returns_segments():
-    manifest, package = flash.load_firmware_manifest("esp32c5")
-    assert manifest["segments"]
-    assert package.endswith("esp32c5")
-
-
-def test_flash_firmware_invokes_esptool(monkeypatch):
-    calls = []
-
-    def fake_run(args):
-        calls.append(args)
-
-    monkeypatch.setattr(flash, "_run_esptool", fake_run)
-
-    manifest = flash.flash_firmware(
-        port="/dev/ttyUSB0",
-        baudrate=921600,
-        board="esp32c5",
-        erase_first=True,
-    )
-
-    assert manifest["label"]
-    assert len(calls) == 2  # erase + write
-    erase_args, write_args = calls
-    assert erase_args[:4] == ["--chip", manifest["chip"], "--port", "/dev/ttyUSB0"]
-    assert "write-flash" in write_args
-    assert any("devboard.ino.bin" in arg for arg in write_args)
-
-
-def test_flash_firmware_unknown_board():
-    with pytest.raises(flash.FirmwareFlashError):
-        flash.flash_firmware(port="/dev/null", baudrate=921600, board="does-not-exist")
-
-
-def test_flash_firmware_handles_no_compress(monkeypatch):
-    calls = []
-
-    def fake_run(args):
-        calls.append(args)
-
-    manifest, package = flash.load_firmware_manifest("esp32c5")
-    custom_manifest = dict(manifest)
-    custom_manifest["compress"] = False
-
-    monkeypatch.setattr(flash, "_run_esptool", fake_run)
-    monkeypatch.setattr(
-        flash,
-        "load_firmware_manifest",
-        lambda _board: (custom_manifest, package),
-    )
-
-    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600)
-
-    assert len(calls) == 1
-    assert "--no-compress" in calls[0]
-
-
-def test_run_esptool_success_with_exit_zero(monkeypatch):
-    recorded = []
-
-    def fake_main(args):
-        recorded.append(list(args))
-        raise SystemExit(0)
-
-    monkeypatch.setattr(flash.esptool, "main", fake_main)
-
-    flash._run_esptool(["ping"])
-
-    assert recorded[0] == ["ping"]
-
-
-def test_run_esptool_failure(monkeypatch):
-    def fake_main(_args):
-        raise SystemExit(2)
-
-    monkeypatch.setattr(flash.esptool, "main", fake_main)
-
-    with pytest.raises(flash.FirmwareFlashError):
-        flash._run_esptool(["bad"])