lr-shuttle 0.2.0__tar.gz → 0.2.1__tar.gz

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/PKG-INFO

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

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lr-shuttle"
-version = "0.2.0"
+version = "0.2.1"
 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.0 → lr_shuttle-0.2.1}/src/lr_shuttle.egg-info/PKG-INFO

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

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/src/shuttle/cli.py

@@ -1977,6 +1977,60 @@ def uart_rx_command(
         console.print("[yellow]No uart.rx events observed[/]")
 
 
+@app.command("power")
+def power_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 the downstream power rail",
+    ),
+):
+    """Query or toggle the downstream power rail."""
+
+    resources = _ctx_resources(ctx)
+    resolved_port = _require_port(port)
+    if enable is None:
+        action = "Querying"
+        label = "power.state"
+        method_name = "power_state"
+    elif enable:
+        action = "Enabling"
+        label = "power.enable"
+        method_name = "power_enable"
+    else:
+        action = "Disabling"
+        label = "power.disable"
+        method_name = "power_disable"
+
+    with spinner(f"{action} power over {resolved_port}"):
+        try:
+            with NDJSONSerialClient(
+                resolved_port,
+                baudrate=baudrate,
+                timeout=timeout,
+                logger=resources.get("logger"),
+                seq_tracker=resources.get("seq_tracker"),
+            ) as client:
+                method = getattr(client, method_name)
+                response = method()
+        except ShuttleSerialError as exc:
+            console.print(f"[red]{exc}[/]")
+            raise typer.Exit(1) from exc
+
+    _render_payload_response(label, response)
+
+
 @app.command("flash")
 def flash_command(
     ctx: typer.Context,

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/src/shuttle/flash.py

@@ -90,12 +90,16 @@ def flash_firmware(
             offset = segment.get("offset")
             file_name = segment.get("file")
             if not offset or not file_name:
-                raise FirmwareFlashError("Manifest segment entries require 'offset' and 'file'")
+                raise FirmwareFlashError(
+                    "Manifest segment entries require 'offset' and 'file'"
+                )
             traversable = resources.files(package) / file_name
             try:
                 file_path = stack.enter_context(resources.as_file(traversable))
             except FileNotFoundError as exc:
-                raise FirmwareFlashError(f"Missing firmware artifact: {file_name}") from exc
+                raise FirmwareFlashError(
+                    f"Missing firmware artifact: {file_name}"
+                ) from exc
             resolved_segments.append((str(offset), Path(file_path)))
 
         if erase_first:

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/src/shuttle/serial_client.py

@@ -324,6 +324,15 @@ class NDJSONSerialClient:
     def ping(self) -> Dict[str, Any]:
         return self._command("ping", {})
 
+    def power_state(self) -> Dict[str, Any]:
+        return self._command("power.state", {})
+
+    def power_enable(self) -> Dict[str, Any]:
+        return self._command("power.enable", {})
+
+    def power_disable(self) -> Dict[str, Any]:
+        return self._command("power.disable", {})
+
     def spi_cfg(self, spi: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         payload: Dict[str, Any] = {}
         if spi:

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/tests/test_cli.py

@@ -2018,6 +2018,86 @@ def test_uart_rx_no_events_message(monkeypatch, recorded_console):
     assert "No uart.rx events observed" in recorded_console.getvalue()
 
 
+def test_power_command_queries_state(monkeypatch, recorded_console):
+    monkeypatch.setattr(cli_module, "spinner", _noop_spinner)
+    record = SimpleNamespace(calls=[])
+
+    class PowerClient:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, exc_tb):
+            return False
+
+        def power_state(self):
+            record.calls.append("power_state")
+            return {
+                "type": "resp",
+                "id": 1,
+                "ok": True,
+                "power": {"enabled": False},
+            }
+
+    monkeypatch.setattr(cli_module, "NDJSONSerialClient", PowerClient)
+    runner = CliRunner()
+    result = runner.invoke(app, ["power", "--port", "/dev/ttyUSB0"])
+
+    assert result.exit_code == 0
+    assert record.calls == ["power_state"]
+    assert "power.state payload" in recorded_console.getvalue()
+
+
+@pytest.mark.parametrize(
+    "flag, expected_call, panel_label",
+    [
+        ("--enable", "power_enable", "power.enable payload"),
+        ("--disable", "power_disable", "power.disable payload"),
+    ],
+)
+def test_power_command_toggles(monkeypatch, recorded_console, flag, expected_call, panel_label):
+    monkeypatch.setattr(cli_module, "spinner", _noop_spinner)
+    record = SimpleNamespace(calls=[])
+
+    class PowerClient:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, exc_tb):
+            return False
+
+        def power_enable(self):
+            record.calls.append("power_enable")
+            return {
+                "type": "resp",
+                "id": 2,
+                "ok": True,
+                "power": {"enabled": True},
+            }
+
+        def power_disable(self):
+            record.calls.append("power_disable")
+            return {
+                "type": "resp",
+                "id": 3,
+                "ok": True,
+                "power": {"enabled": False},
+            }
+
+    monkeypatch.setattr(cli_module, "NDJSONSerialClient", PowerClient)
+    runner = CliRunner()
+    result = runner.invoke(app, ["power", "--port", "/dev/ttyUSB0", flag])
+
+    assert result.exit_code == 0
+    assert record.calls == [expected_call]
+    assert panel_label in recorded_console.getvalue()
+
+
 def test_render_uart_event_handles_invalid_payload(monkeypatch):
     buffer = io.StringIO()
     console = Console(file=buffer, force_terminal=False, width=80)

{lr_shuttle-0.2.0 → lr_shuttle-0.2.1}/tests/test_serial_client.py

@@ -73,17 +73,21 @@ def test_ndjson_serial_client_payload_builders():
     client.spi_disable()
     client.uart_sub({"enable": True, "gap_ms": 5})
     client.uart_sub()
-
-    assert calls[0][0] == "spi.cfg"
-    assert calls[0][1]["spi"]["hz"] == 123
-    assert calls[1][0] == "uart.cfg"
-    assert calls[1][1]["uart"]["baudrate"] == 9600
-    assert calls[2][0] == "spi.enable"
-    assert calls[3][0] == "spi.disable"
-    assert calls[4][0] == "uart.sub"
-    assert calls[4][1]["uart"]["sub"] == {"enable": True, "gap_ms": 5}
-    assert calls[5][0] == "uart.sub"
-    assert calls[5][1] == {}
+    client.power_state()
+    client.power_enable()
+    client.power_disable()
+
+    assert calls == [
+        ("spi.cfg", {"spi": {"hz": 123}}),
+        ("uart.cfg", {"uart": {"baudrate": 9600}}),
+        ("spi.enable", {}),
+        ("spi.disable", {}),
+        ("uart.sub", {"uart": {"sub": {"enable": True, "gap_ms": 5}}}),
+        ("uart.sub", {}),
+        ("power.state", {}),
+        ("power.enable", {}),
+        ("power.disable", {}),
+    ]
 
 
 def test_record_sequence_no_tracker(monkeypatch):