lr-shuttle 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

{lr_shuttle-0.2.2.dist-info → lr_shuttle-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.2
+Version: 0.2.4
 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.2.dist-info → lr_shuttle-0.2.4.dist-info}/RECORD

@@ -1,18 +1,18 @@
-shuttle/cli.py,sha256=eMJEEmHG6Ar3vQsrQmCbPLY0pHUJg6gUyUDCaW0KNGM,87851
+shuttle/cli.py,sha256=lou_JvWNoMXxoyXyz5MSIyAUZEUAe0CmXaBnl_gqLMY,93507
 shuttle/constants.py,sha256=GUlAg3iEuPxLQ2mDCvlv5gVXHnlawl_YeLtaUSqsnPM,757
 shuttle/flash.py,sha256=9ph23MHL40SjKZoL38Sbd3JbykGb-ECxvzBzCIjAues,4492
-shuttle/prodtest.py,sha256=1q-1dZYtrWBpI_e0jPgROVGbb_42Y0q0DIxDoo4MWUk,8020
-shuttle/serial_client.py,sha256=CnqWpC4CyxNXzsQQgRQsGwkDf19OoIEYvipu4kt2IQo,17392
+shuttle/prodtest.py,sha256=nI8k2OndhqsOv8BMtXwfcpGEdmHU7ywbIgMuW49EULU,8006
+shuttle/serial_client.py,sha256=bUpTs6MmJkpYBgtNYZZ0EYaybkLlrM7MlhWxHLQPh3U,18185
 shuttle/timo.py,sha256=1K18y0QtDF2lw2Abeok9PgrpPUiCEbQdGQXOQik75Hw,16481
 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=vH-IBzbJCpSKgCLDl6snXqe2d5PFJJ3RDVQq41b3iKg,378880
+shuttle/firmware/esp32c5/devboard.ino.bin,sha256=CxWJQYlbL7zu9nkUzBQ0PQQET4XHZKFoxMzm9tZonqk,1099040
 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.2.dist-info/METADATA,sha256=eS1NFB_YNkvsq7eT4akMzyUij0ormtqHHtagAMghonA,13611
-lr_shuttle-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lr_shuttle-0.2.2.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
-lr_shuttle-0.2.2.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
-lr_shuttle-0.2.2.dist-info/RECORD,,
+lr_shuttle-0.2.4.dist-info/METADATA,sha256=EEgzPGFjeZ3L04elKT8VcUkiRjm0CyUn9dAN5Cq4_IQ,13611
+lr_shuttle-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lr_shuttle-0.2.4.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
+lr_shuttle-0.2.4.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
+lr_shuttle-0.2.4.dist-info/RECORD,,

shuttle/cli.py

@@ -2,6 +2,8 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
+import ipaddress
+import re
 import string
 import sys
 import time
@@ -105,7 +107,12 @@ for entry in PRODTEST_TX_POWER_LEVELS:
     for alias in entry["aliases"]:
         PRODTEST_TX_POWER_ALIASES[alias.lower()] = entry["value"]
     PRODTEST_TX_POWER_ALIASES[str(entry["value"])] = entry["value"]
-PRODTEST_TX_POWER_CANONICAL = [entry["aliases"][0] for entry in PRODTEST_TX_POWER_LEVELS]
+PRODTEST_TX_POWER_CANONICAL = [
+    entry["aliases"][0] for entry in PRODTEST_TX_POWER_LEVELS
+]
+
+_HOST_PORT_PATTERN = re.compile(r"^[A-Za-z0-9_.-]+:\d+$")
+_IPV6_HOST_PORT_PATTERN = re.compile(r"^\[[0-9A-Fa-f:]+\]:\d+$")
 
 # Backwards-compatible aliases for tests and external callers
 _SerialLogger = SerialLogger
@@ -154,9 +161,7 @@ def _resolve_prodtest_power_choice(value: str) -> Tuple[int, Dict[str, str]]:
             resolved = parsed
     if resolved is None:
         allowed = ", ".join(PRODTEST_TX_POWER_CANONICAL)
-        raise typer.BadParameter(
-            f"Power must be one of: {allowed} or an index 0-7"
-        )
+        raise typer.BadParameter(f"Power must be one of: {allowed} or an index 0-7")
     return resolved, PRODTEST_TX_POWER_META[resolved]
 
 
@@ -251,9 +256,22 @@ def _resolve_uart_payload(
     return payload_bytes.hex(), len(payload_bytes)
 
 
+def _normalize_port(port: str) -> str:
+    trimmed = port.strip()
+    if not trimmed:
+        raise typer.BadParameter("Serial port is required (use --port or SHUTTLE_PORT)")
+    if "://" in trimmed:
+        return trimmed
+    if trimmed.startswith("/") or trimmed.startswith("\\"):
+        return trimmed
+    if _HOST_PORT_PATTERN.match(trimmed) or _IPV6_HOST_PORT_PATTERN.match(trimmed):
+        return f"socket://{trimmed}"
+    return trimmed
+
+
 def _require_port(port: Optional[str]) -> str:
     if port:
-        return port
+        return _normalize_port(port)
     raise typer.BadParameter("Serial port is required (use --port or SHUTTLE_PORT)")
 
 
@@ -269,6 +287,16 @@ def _parse_int_option(value: str, *, name: str) -> int:
     return parsed
 
 
+def _parse_ipv4(value: Optional[str], *, name: str) -> Optional[str]:
+    if value is None:
+        return None
+    try:
+        ipaddress.IPv4Address(value)
+    except ipaddress.AddressValueError as exc:
+        raise typer.BadParameter(f"{name} must be a valid IPv4 address") from exc
+    return value
+
+
 def _parse_prodtest_mask(value: str) -> bytes:
     try:
         return prodtest.mask_from_hex(value)
@@ -1521,17 +1549,49 @@ def prodtest_ping(
         logger=resources.get("logger"),
         seq_tracker=resources.get("seq_tracker"),
     )
-    if not responses or len(responses) < 2:
+    if not responses:
         console.print("[red]Device returned no response[/]")
         raise typer.Exit(1)
-    rx2 = responses[1].get("rx", "")
-    if rx2 and isinstance(rx2, str):
-        rx_bytes = bytes.fromhex(rx2)
-        if rx_bytes and rx_bytes[0] == 0x2D:  # ord('-')
-            console.print("[green]Ping successful: got '-' response[/]")
-            return
-    console.print(f"[red]Ping failed: expected '-' (0x2D), got: {rx2}[/]")
-    raise typer.Exit(1)
+
+    failed_idx = next(
+        (idx for idx, resp in enumerate(responses) if not resp.get("ok")), None
+    )
+    if failed_idx is not None:
+        phase = "command" if failed_idx == 0 else "payload"
+        _render_spi_response(
+            f"prodtest ping ({phase})",
+            responses[failed_idx],
+            command_label=f"spi.xfer (prodtest {phase})",
+        )
+        raise typer.Exit(1)
+
+    if len(responses) != len(sequence):
+        console.print(
+            "[red]Prodtest command halted before completing all SPI phases[/]"
+        )
+        raise typer.Exit(1)
+
+    command_response, payload_response = responses
+    _render_spi_response(
+        "prodtest ping (command)",
+        command_response,
+        command_label="spi.xfer (prodtest command)",
+    )
+    _render_spi_response(
+        "prodtest ping (payload)",
+        payload_response,
+        command_label="spi.xfer (prodtest payload)",
+    )
+
+    rx_bytes = _decode_hex_response(payload_response, label="prodtest ping (payload)")
+    if not rx_bytes or rx_bytes[0] != 0x2D:  # ord('-')
+        console.print(
+            "[red]Ping failed: expected '-' (0x2D), got: "
+            f"{_format_hex(payload_response.get('rx', ''))}[/]"
+        )
+        raise typer.Exit(1)
+
+    console.print("[green]Ping successful: got '-' response[/]")
 
 
 @prodtest_app.command("antenna")
@@ -1561,9 +1621,7 @@ def prodtest_antenna(
         antenna_value = PRODTEST_ANTENNA_CHOICES[normalized]
     except KeyError as exc:
         allowed = ", ".join(sorted(PRODTEST_ANTENNA_CHOICES))
-        raise typer.BadParameter(
-            f"Antenna must be one of: {allowed}"
-        ) from exc
+        raise typer.BadParameter(f"Antenna must be one of: {allowed}") from exc
 
     sequence = [prodtest.select_antenna(antenna_value)]
     responses = _execute_timo_sequence(
@@ -1705,7 +1763,9 @@ def prodtest_hw_device_id(
         raise typer.Exit(1)
 
     if len(responses) != len(sequence):
-        console.print("[red]Prodtest command halted before completing all SPI phases[/]")
+        console.print(
+            "[red]Prodtest command halted before completing all SPI phases[/]"
+        )
         raise typer.Exit(1)
 
     result_response = responses[-1]
@@ -1796,11 +1856,11 @@ def prodtest_serial_number(
             result_response,
             command_label="spi.xfer (prodtest payload)",
         )
-        rx_bytes = _decode_hex_response(
-            result_response, label="prodtest serial-number"
-        )
+        rx_bytes = _decode_hex_response(result_response, label="prodtest serial-number")
         if len(rx_bytes) < prodtest.SERIAL_NUMBER_LEN:
-            console.print("[red]Prodtest serial-number response shorter than expected[/]")
+            console.print(
+                "[red]Prodtest serial-number response shorter than expected[/]"
+            )
             raise typer.Exit(1)
         serial_bytes = rx_bytes[-prodtest.SERIAL_NUMBER_LEN :]
         console.print(f"Serial number: {_format_hex(serial_bytes.hex())}")
@@ -2328,6 +2388,125 @@ def uart_sub_command(
     _render_payload_response("uart.sub", response)
 
 
+@app.command("wifi-cfg")
+def wifi_cfg_command(
+    ctx: typer.Context,
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port or host:port (e.g., /dev/ttyUSB0 or 192.168.1.10:5000)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+    ssid: Optional[str] = typer.Option(
+        None,
+        "--ssid",
+        help="Set the station SSID",
+        show_default=False,
+    ),
+    psk: Optional[str] = typer.Option(
+        None,
+        "--psk",
+        help="Set the WPA/WPA2/WPA3 passphrase",
+        show_default=False,
+    ),
+    dhcp: Optional[bool] = typer.Option(
+        None,
+        "--dhcp/--static",
+        help="Enable DHCP or force static IPv4 addressing",
+    ),
+    ip_addr: Optional[str] = typer.Option(
+        None,
+        "--ip",
+        help="Static IPv4 address (requires --static or other static fields)",
+        show_default=False,
+    ),
+    netmask: Optional[str] = typer.Option(
+        None,
+        "--netmask",
+        help="Static subnet mask (e.g., 255.255.255.0)",
+        show_default=False,
+    ),
+    gateway: Optional[str] = typer.Option(
+        None,
+        "--gateway",
+        help="Static default gateway IPv4 address",
+        show_default=False,
+    ),
+    dns: Optional[str] = typer.Option(
+        None,
+        "--dns",
+        help="Primary DNS server IPv4 address",
+        show_default=False,
+    ),
+    dns_alt: Optional[str] = typer.Option(
+        None,
+        "--dns-alt",
+        help="Secondary DNS server IPv4 address",
+        show_default=False,
+    ),
+):
+    """Query or update Wi-Fi credentials and network settings."""
+
+    resources = _ctx_resources(ctx)
+    wifi_payload: Dict[str, Any] = {}
+    if ssid is not None:
+        wifi_payload["ssid"] = ssid
+    if psk is not None:
+        wifi_payload["psk"] = psk
+    if dhcp is not None:
+        wifi_payload["dhcp"] = dhcp
+
+    network_payload: Dict[str, Any] = {}
+    parsed_ip = _parse_ipv4(ip_addr, name="--ip")
+    parsed_mask = _parse_ipv4(netmask, name="--netmask")
+    parsed_gateway = _parse_ipv4(gateway, name="--gateway")
+    parsed_dns_primary = _parse_ipv4(dns, name="--dns")
+    parsed_dns_secondary = _parse_ipv4(dns_alt, name="--dns-alt")
+
+    if parsed_ip is not None:
+        network_payload["ip"] = parsed_ip
+    if parsed_mask is not None:
+        network_payload["netmask"] = parsed_mask
+    if parsed_gateway is not None:
+        network_payload["gateway"] = parsed_gateway
+
+    dns_entries = [
+        entry for entry in (parsed_dns_primary, parsed_dns_secondary) if entry
+    ]
+    if dns_entries:
+        network_payload["dns"] = dns_entries
+
+    if network_payload:
+        if wifi_payload.get("dhcp") is True:
+            raise typer.BadParameter(
+                "Static network options cannot be combined with --dhcp"
+            )
+        wifi_payload.setdefault("dhcp", False)
+        wifi_payload["network"] = network_payload
+
+    resolved_port = _require_port(port)
+    action = "Updating" if wifi_payload else "Querying"
+    with spinner(f"{action} wifi.cfg 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.wifi_cfg(wifi_payload if wifi_payload else None)
+        except ShuttleSerialError as exc:
+            console.print(f"[red]{exc}[/]")
+            raise typer.Exit(1) from exc
+
+    _render_payload_response("wifi.cfg", response)
+
+
 @app.command("uart-tx")
 def uart_tx_command(
     ctx: typer.Context,

shuttle/prodtest.py

@@ -62,9 +62,7 @@ def command(
 ) -> dict:
     """Build an NDJSON-ready spi.xfer payload for a prodtest command."""
 
-    return timo.command_payload(
-        _build_command_bytes(opcode, arguments), params=params
-    )
+    return timo.command_payload(_build_command_bytes(opcode, arguments), params=params)
 
 
 def reset() -> dict:

shuttle/serial_client.py

@@ -228,9 +228,24 @@ class NDJSONSerialClient:
         seq_tracker: Optional[SequenceTracker] = None,
     ):
         try:
-            self._serial = serial.Serial(port=port, baudrate=baudrate, timeout=timeout)
+            self._serial = serial.serial_for_url(
+                url=port,
+                baudrate=baudrate,
+                timeout=timeout,
+                do_not_open=True,
+            )
+        except SerialException as exc:  # pragma: no cover - hardware specific
+            raise ShuttleSerialError(f"Unable to initialize {port}: {exc}") from exc
+
+        try:
+            if getattr(self._serial, "open", None) is not None:
+                if not getattr(self._serial, "is_open", False):
+                    self._serial.open()
         except SerialException as exc:  # pragma: no cover - hardware specific
             raise ShuttleSerialError(f"Unable to open {port}: {exc}") from exc
+        except AttributeError:
+            # Test stubs without an open() method are already "connected"
+            pass
         self._serial.reset_input_buffer()
         self._lock = threading.Lock()
         self._pending: Dict[int, CommandFuture] = {}
@@ -345,6 +360,12 @@ class NDJSONSerialClient:
             payload["uart"] = uart
         return self._command("uart.cfg", payload)
 
+    def wifi_cfg(self, wifi: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {}
+        if wifi:
+            payload["wifi"] = wifi
+        return self._command("wifi.cfg", payload)
+
     def uart_tx(self, data: str, port: Optional[int] = None) -> Dict[str, Any]:
         payload: Dict[str, Any] = {"data": data}
         if port is not None: