python-esp-bridge 0.0.2__tar.gz → 0.1.1__tar.gz

{python_esp_bridge-0.0.2 → python_esp_bridge-0.1.1}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: python-esp-bridge
-Version: 0.0.2
-Summary: Control every ESP32 peripheral from Python over USB serial — GPIO, ADC, DAC, PWM, touch, I2C, SPI, UART, Wi-Fi sockets, BLE
+Version: 0.1.1
+Summary: Control every ESP32 peripheral from Python over USB serial or Bluetooth — GPIO, ADC, DAC, PWM, touch, I2C, SPI, UART, Wi-Fi sockets, BLE
 Project-URL: Homepage, https://github.com/HamzaYslmn/python-esp-bridge
 Author: HamzaYslmn
 Keywords: ble,bridge,esp32,firmata,gpio,i2c,raspberry-pi,serial,spi
 Requires-Python: >=3.10
 Requires-Dist: pyserial>=3.5
+Provides-Extra: ble
+Requires-Dist: bleak>=0.22; extra == 'ble'
 Provides-Extra: oled
 Requires-Dist: pillow>=10; extra == 'oled'
 Description-Content-Type: text/markdown

{python_esp_bridge-0.0.2 → python_esp_bridge-0.1.1}/espbridge/__init__.py

@@ -1,6 +1,6 @@
 """espbridge — control every ESP32 peripheral from Python over USB serial.
 
-Flash esp/esp.ino once, then:
+Flash firmware/firmware.ino once, then:
 
     from espbridge import Bridge
 
@@ -15,6 +15,7 @@ Flash esp/esp.ino once, then:
 from .bridge import Bridge, BridgeSet, Info, connect_all
 from .constants import Cap, ChipModel, Status
 from .errors import (
+    AuthError,
     BridgeError,
     BridgeTimeoutError,
     NoDeviceError,
@@ -22,18 +23,27 @@ from .errors import (
     RemoteError,
     UnsupportedError,
 )
-from .transport import find_ports
+from .transports import find_ports
 
-__version__ = "0.0.2"
+
+def find_ble_devices(timeout: float = 5.0):
+    """Scan for bridges advertising over Bluetooth (needs the [ble] extra)."""
+    from .transports.ble import find_ble_devices as _scan
+
+    return _scan(timeout)
+
+__version__ = "0.1.1"
 
 __all__ = [
     "Bridge",
     "BridgeSet",
     "connect_all",
+    "find_ble_devices",
     "Info",
     "Cap",
     "ChipModel",
     "Status",
+    "AuthError",
     "BridgeError",
     "BridgeTimeoutError",
     "NoDeviceError",

{python_esp_bridge-0.0.2 → python_esp_bridge-0.1.1}/espbridge/bridge.py

@@ -10,6 +10,7 @@ from dataclasses import dataclass
 
 from . import constants as C
 from .errors import (
+    AuthError,
     BridgeError,
     BridgeTimeoutError,
     NoDeviceError,
@@ -18,7 +19,7 @@ from .errors import (
     UnsupportedError,
 )
 from .protocol import Frame, FrameSplitter, decode_frame, encode_frame
-from .transport import SerialTransport, find_ports
+from .transports import SerialTransport, find_ports
 
 
 @dataclass(frozen=True)
@@ -78,6 +79,12 @@ class Bridge:
 
     >>> esp = Bridge(name="relays")
     >>> esp = Bridge(mac="24:a1:60:12:34:56")
+
+    Over Bluetooth instead of USB (firmware default password "espbridge",
+    change it at the top of firmware/firmware.ino):
+
+    >>> esp = Bridge(ble=True)                      # the only advertising bridge
+    >>> esp = Bridge(ble="relays", password="espbridge")
     """
 
     def __init__(
@@ -86,6 +93,8 @@ class Bridge:
         *,
         name: str | None = None,
         mac: str | None = None,
+        ble: bool | str = False,
+        password: str | None = None,
         baud: int = 115200,
         upgrade_baud: bool = True,
         target_baud: int | None = None,
@@ -98,18 +107,22 @@ class Bridge:
         self.reset_on_exit = False  # set for real only once connected (see below)
         self.info: Info | None = None
 
-        # Candidate ports: explicit transport/port, or every ESP32-like port.
+        # Candidates: (transport factory, label, usb_chip).
         if transport is not None:
-            candidates = [(transport, None, getattr(transport, "usb_chip", None))]
+            candidates = [(lambda t=transport: t, "transport",
+                           getattr(transport, "usb_chip", None))]
+        elif ble:
+            candidates = self._ble_candidates(ble, name, mac)
         elif port is not None:
             chip = next((p.usb_chip for p in find_ports() if p.device == port), None)
-            candidates = [(None, port, chip)]
+            candidates = [(lambda p=port, c=chip: SerialTransport(p, baud, usb_chip=c),
+                           port, chip)]
         else:
             ports = find_ports()
             if not ports:
                 raise NoDeviceError(
                     "no ESP32 serial port found (CP210x/CH340/CH9102/native USB); "
-                    "pass port='COM5' / '/dev/ttyUSB0' explicitly"
+                    "pass port='COM5' / '/dev/ttyUSB0' explicitly — or ble=True"
                 )
             if name is None and mac is None and len(ports) > 1:
                 names = ", ".join(p.device for p in ports)
@@ -117,41 +130,92 @@ class Bridge:
                     f"multiple ESP32-like ports found ({names}); pass port=, "
                     f"name= or mac= — or use espbridge.connect_all()"
                 )
-            candidates = [(None, p.device, p.usb_chip) for p in ports]
+            candidates = [(lambda p=p: SerialTransport(p.device, baud, usb_chip=p.usb_chip),
+                           p.device, p.usb_chip) for p in ports]
 
         probing = len(candidates) > 1
         errors: list[str] = []
-        for t, prt, chip in candidates:
+        for factory, label, chip in candidates:
             self._reset_state()
             try:
-                self._t = t if t is not None else SerialTransport(prt, baud, usb_chip=chip)
+                self._t = factory()
             except Exception as e:
-                errors.append(f"{prt}: {e}")
+                errors.append(f"{label}: {e}")
                 continue
             self._reader = threading.Thread(target=self._read_loop, daemon=True,
                                             name="espbridge-reader")
             self._reader.start()
             try:
-                self._handshake(reset_on_open)
+                if getattr(self._t, "needs_auth", False):
+                    self._auth(password)
+                    self._handshake(reset_on_open=False)
+                else:
+                    self._handshake(reset_on_open)
                 assert self.info is not None
                 if self._matches(name, mac):
-                    if upgrade_baud:
+                    if upgrade_baud and getattr(self._t, "has_baud", True):
                         self._upgrade_baud(baud, target_baud)
                     self.reset_on_exit = reset_on_exit
                     return
-                errors.append(f"{prt or 'transport'}: name={self.info.name!r} "
+                errors.append(f"{label}: name={self.info.name!r} "
                               f"mac={self.info.mac} (no match)")
                 self.close()
             except (BridgeTimeoutError, ProtocolError) as e:
                 self.close()
                 if not probing:
                     raise
-                errors.append(f"{prt or 'transport'}: {e}")
+                errors.append(f"{label}: {e}")
             except BaseException:
                 self.close()
                 raise
         raise NoDeviceError("no matching bridge found — " + "; ".join(errors))
 
+    @staticmethod
+    def _ble_candidates(ble: bool | str, name: str | None, mac: str | None):
+        from .transports.ble import BleTransport, find_ble_devices
+
+        target = ble if isinstance(ble, str) else None
+        devs = find_ble_devices()
+        if target is not None:
+            tmac = _norm_mac(target)
+            devs = [d for d in devs
+                    if d.name == target or d.device_name == target
+                    or _norm_mac(d.address) == tmac or _norm_mac(d.mac) == tmac]
+        # The advertised name carries the bridge MAC and custom name: narrow
+        # the candidates before connecting when the caller passed name=/mac=.
+        # On no match keep the full list (adv data can be stale/truncated) —
+        # the post-connect _matches() check stays authoritative either way.
+        if mac is not None:
+            devs = [d for d in devs if _norm_mac(d.mac) == _norm_mac(mac)] or devs
+        if name is not None:
+            devs = [d for d in devs if d.device_name == name] or devs
+        if not devs:
+            what = f" named/at {target!r}" if target else ""
+            raise NoDeviceError(
+                f"no bridge{what} found over Bluetooth — is the board powered, "
+                f"in range, and flashed with BRIDGE_BLE_LINK enabled?"
+            )
+        if target is None and name is None and mac is None and len(devs) > 1:
+            names = ", ".join(d.name or d.address for d in devs)
+            raise NoDeviceError(
+                f"multiple bridges advertising ({names}); pass ble='name-or-mac'"
+            )
+        return [(lambda d=d: BleTransport(d.address),
+                 f"BLE {d.name or d.address}", None) for d in devs]
+
+    def _auth(self, password: str | None) -> None:
+        """Authenticate a wireless link (SYS_AUTH) before the handshake."""
+        pw = (C.DEFAULT_PASSWORD if password is None else password).encode()
+        try:
+            self.request(C.SYS_AUTH, pw, timeout=5.0)
+        except RemoteError as e:
+            if e.status == C.Status.DENIED:
+                raise AuthError(
+                    "bridge rejected the password — check BRIDGE_PASSWORD at "
+                    "the top of firmware/firmware.ino"
+                ) from None
+            raise
+
     def _reset_state(self) -> None:
         self._splitter = FrameSplitter()
         self._pending: dict[int, _Pending] = {}
@@ -203,13 +267,13 @@ class Bridge:
                     continue
         if not self._ready.is_set():
             raise BridgeTimeoutError(
-                "no response from bridge firmware — is it flashed? (esp/README.md)"
+                "no response from bridge firmware — is it flashed? (firmware/README.md)"
             )
         assert self.info is not None
         if self.info.protocol != C.PROTOCOL_VERSION:
             raise ProtocolError(
                 f"protocol mismatch: firmware speaks v{self.info.protocol}, "
-                f"this library v{C.PROTOCOL_VERSION} — reflash esp/esp.ino or "
+                f"this library v{C.PROTOCOL_VERSION} — reflash firmware.ino or "
                 f"update python-esp-bridge"
             )
 
@@ -232,7 +296,29 @@ class Bridge:
                 continue
         # Could not talk at the new baud: fall back.
         self._t.set_baudrate(current)
-        self.ping(b"fallback")
+        try:
+            self.ping(b"fallback")
+        except BridgeTimeoutError:
+            # The firmware already switched to `target` and can't hear us.
+            # Reopen the port: the open-time DTR/RTS toggle resets the board
+            # (reliable even where a manual reset pulse is not).
+            self._reconnect(current)
+
+    def _reconnect(self, baud: int) -> None:
+        """Reopen the serial port and redo the handshake (recovers a dead link)."""
+        port = getattr(getattr(self._t, "ser", None), "port", None)
+        chip = getattr(self._t, "usb_chip", None)
+        if port is None:
+            raise BridgeTimeoutError("link lost and transport cannot be reopened")
+        self._t.close()
+        self._reader.join(timeout=1.0)
+        time.sleep(0.3)  # let the device reboot from the close-time reset
+        self._reset_state()
+        self._t = SerialTransport(port, baud, usb_chip=chip)
+        self._reader = threading.Thread(target=self._read_loop, daemon=True,
+                                        name="espbridge-reader")
+        self._reader.start()
+        self._handshake(reset_on_open=True)
 
     def close(self) -> None:
         if self._closing:

{python_esp_bridge-0.0.2 → python_esp_bridge-0.1.1}/espbridge/cli.py

@@ -7,7 +7,7 @@ import sys
 from . import __version__
 from .bridge import Bridge, connect_all
 from .errors import BridgeError
-from .transport import find_ports
+from .transports import find_ports
 
 
 def _print_info(esp: Bridge) -> None:
@@ -32,10 +32,18 @@ def main(argv: list[str] | None = None) -> int:
     ap.add_argument("--version", action="version", version=f"espbridge {__version__}")
     ap.add_argument("-p", "--port", help="serial port (default: auto-detect)")
     ap.add_argument("-n", "--name", help="select device by stored name")
+    ap.add_argument("-b", "--ble", nargs="?", const=True, metavar="NAME_OR_MAC",
+                    help="connect over Bluetooth instead of USB")
+    ap.add_argument("--password", help="Bluetooth link password "
+                                       "(default: 'espbridge')")
     ap.add_argument("--no-baud-upgrade", action="store_true",
                     help="stay at 115200 instead of upgrading the link speed")
     sub = ap.add_subparsers(dest="cmd")
     sub.add_parser("ports", help="list ESP32-like serial ports")
+    p_scan = sub.add_parser("scan", help="connect to every attached device and "
+                                         "list port/name/chip/mac")
+    p_scan.add_argument("--ble", action="store_true", dest="scan_ble",
+                        help="scan for bridges advertising over Bluetooth")
     sub.add_parser("info", help="connect and print firmware/chip info (default; "
                                 "shows every device when several are attached)")
     p_name = sub.add_parser("set-name", help="store a device name on the ESP32 (NVS)")
@@ -43,8 +51,25 @@ def main(argv: list[str] | None = None) -> int:
     args = ap.parse_args(argv)
 
     kwargs = dict(upgrade_baud=not args.no_baud_upgrade)
+    if args.ble:
+        kwargs["ble"] = args.ble
+    if args.password is not None:
+        kwargs["password"] = args.password
 
     try:
+        if args.cmd == "scan" and args.scan_ble:
+            from .transports.ble import find_ble_devices
+
+            devs = find_ble_devices()
+            if not devs:
+                print("no bridges advertising over Bluetooth")
+                return 1
+            print(f"{'NAME':<16s} {'MAC':<18s} {'ADVERTISED':<32s} RSSI")
+            for d in devs:
+                print(f"{d.device_name or '-':<16s} {d.mac or '-':<18s} "
+                      f"{d.name:<32s} {d.rssi} dBm")
+            return 0
+
         if args.cmd == "ports":
             ports = find_ports()
             if not ports:
@@ -54,14 +79,36 @@ def main(argv: list[str] | None = None) -> int:
                 print(f"{p.device}\t{p.usb_chip}\t{p.description}")
             return 0
 
+        if args.cmd == "scan":
+            ports = find_ports()
+            if not ports:
+                print("no ESP32-like serial ports found")
+                return 1
+            print(f"{'PORT':<12s} {'NAME':<16s} {'CHIP':<10s} {'MAC':<17s} FW")
+            rc = 0
+            for p in ports:
+                try:
+                    # info only — skip the baud upgrade for a quicker probe
+                    with Bridge(p.device, upgrade_baud=False) as esp:
+                        info = esp.info
+                        fw = ".".join(map(str, info.fw_version))
+                        print(f"{p.device:<12s} {info.name or '-':<16s} "
+                              f"{info.chip.name:<10s} {info.mac:<17s} v{fw}")
+                except BridgeError as e:
+                    print(f"{p.device:<12s} error: {e}")
+                    rc = 1
+            return rc
+
         if args.cmd == "set-name":
             with Bridge(args.port, name=args.name, **kwargs) as esp:
                 esp.set_name(args.new_name)
                 print(f"{esp.info.mac} is now named {args.new_name!r}")
+                print("(the Bluetooth advertised name updates on next reset)")
             return 0
 
         # default: info
-        if args.port is None and args.name is None and len(find_ports()) > 1:
+        if args.port is None and args.name is None and not args.ble \
+                and len(find_ports()) > 1:
             with connect_all(**kwargs) as boards:
                 for i, esp in enumerate(boards):
                     if i:

{python_esp_bridge-0.0.2 → python_esp_bridge-0.1.1}/espbridge/constants.py

@@ -1,6 +1,6 @@
 """python-esp-bridge — shared protocol contract.
 
-MUST stay in sync with esp/src/espbridge/commands.h.
+MUST stay in sync with firmware/src/espbridge/commands.h.
 """
 from __future__ import annotations
 
@@ -34,6 +34,7 @@ class Status(enum.IntEnum):
     WIFI = 0x0A
     SOCKET = 0x0B
     CRC = 0x0C
+    DENIED = 0x0D  # wireless link not authenticated (see SYS_AUTH)
 
 
 class Cap(enum.IntFlag):
@@ -46,6 +47,7 @@ class Cap(enum.IntFlag):
     PSRAM = 1 << 6
     NATIVE_USB = 1 << 7
     BLE_FW = 1 << 8
+    BLE_LINK = 1 << 9  # bridge reachable over the BLE transport
 
 
 class ChipModel(enum.IntEnum):
@@ -82,6 +84,7 @@ SYS_SET_BAUD = _cmd(MOD_SYS, 0x03)
 SYS_RESET = _cmd(MOD_SYS, 0x04)
 SYS_FREE_HEAP = _cmd(MOD_SYS, 0x05)
 SYS_SET_NAME = _cmd(MOD_SYS, 0x06)
+SYS_AUTH = _cmd(MOD_SYS, 0x07)
 SYS_READY = _cmd(MOD_SYS, 0x80)
 SYS_LOG = _cmd(MOD_SYS, 0x81)
 
@@ -189,6 +192,13 @@ KNOWN_USB_IDS = {
     (0x303A, None): "native",     # Espressif native USB (S2/S3/C3/...)
 }
 
+# BLE link: Nordic-UART-style GATT service the firmware exposes as a transport.
+# MUST stay in sync with firmware link_ble.cpp.
+BLE_LINK_SERVICE_UUID = "6e400001-b5a3-f393-e0a9-e50e24dcca9e"
+BLE_LINK_RX_UUID = "6e400002-b5a3-f393-e0a9-e50e24dcca9e"  # host -> board (write)
+BLE_LINK_TX_UUID = "6e400003-b5a3-f393-e0a9-e50e24dcca9e"  # board -> host (notify)
+DEFAULT_PASSWORD = "espbridge"  # firmware default; change in firmware.ino
+
 # Safe upgraded baud per bridge chip (conservative defaults; CH340 can do 2M).
 UPGRADE_BAUD = {
     "cp210x": 921600,

{python_esp_bridge-0.0.2 → python_esp_bridge-0.1.1}/espbridge/errors.py

@@ -24,6 +24,11 @@ class UnsupportedError(BridgeError):
     """The connected chip lacks this capability (e.g. DAC on ESP32-S3)."""
 
 
+class AuthError(BridgeError):
+    """The bridge rejected the wireless-link password (see BRIDGE_PASSWORD
+    at the top of firmware/firmware.ino)."""
+
+
 class RemoteError(BridgeError):
     """The firmware returned an error status for a request."""
 

python_esp_bridge-0.1.1/espbridge/transport.py

@@ -0,0 +1,5 @@
+"""Back-compat shim — transports now live in espbridge.transports.*"""
+from .transports.serial import PortInfo, SerialTransport, autodetect_port, find_ports
+from .transports.mock import MockTransport
+
+__all__ = ["PortInfo", "SerialTransport", "MockTransport", "autodetect_port", "find_ports"]

python_esp_bridge-0.1.1/espbridge/transports/__init__.py

@@ -0,0 +1,22 @@
+"""Transports: byte links the Bridge protocol runs over (serial, BLE, mock).
+
+A transport provides:
+    read() -> bytes        # whatever is available (may block briefly, b"" ok)
+    write(data: bytes)     # send raw bytes
+    close()
+    set_baudrate(baud)     # serial links only; no-op elsewhere
+    pulse_reset()          # serial links only; no-op elsewhere
+    usb_chip: str | None   # adapter hint for baud upgrade ("cp210x", ...)
+    has_baud: bool         # False to skip baud negotiation entirely
+    needs_auth: bool       # True = Bridge sends SYS_AUTH before the handshake
+"""
+from .serial import PortInfo, SerialTransport, autodetect_port, find_ports
+from .mock import MockTransport
+
+__all__ = [
+    "PortInfo",
+    "SerialTransport",
+    "MockTransport",
+    "autodetect_port",
+    "find_ports",
+]

python_esp_bridge-0.1.1/espbridge/transports/ble.py

@@ -0,0 +1,172 @@
+"""Bluetooth (BLE) transport — talk to the bridge with no USB cable.
+
+The firmware advertises a Nordic-UART-style GATT service (see firmware
+link_ble.cpp); this transport carries the exact same COBS frame stream over
+it. Requires the `bleak` package: ``pip install python-esp-bridge[ble]``.
+
+bleak is asyncio-based; a private event loop runs in a daemon thread so the
+transport exposes the same blocking read()/write() interface as the serial
+one. Notifications land in a queue that read() drains.
+"""
+from __future__ import annotations
+
+import queue
+import threading
+from dataclasses import dataclass
+
+from ..constants import BLE_LINK_RX_UUID, BLE_LINK_SERVICE_UUID, BLE_LINK_TX_UUID
+from ..errors import BridgeError, NoDeviceError
+
+
+ADV_NAME_PREFIX = "espbridge_"  # firmware advertises espbridge_<mac>[_<name>]
+
+
+@dataclass(frozen=True)
+class BleDeviceInfo:
+    name: str     # advertised name: "espbridge_c049efd03fe0" or "espbridge_c049efd03fe0_relays"
+    address: str  # MAC on Windows/Linux, CoreBluetooth UUID on macOS
+    rssi: int
+
+    def _parts(self) -> tuple[str, str]:
+        rest = self.name.removeprefix(ADV_NAME_PREFIX)
+        hexpart, _, custom = rest.partition("_")
+        if len(hexpart) == 12 and all(c in "0123456789abcdef" for c in hexpart):
+            return hexpart, custom
+        return "", ""
+
+    @property
+    def mac(self) -> str:
+        """Bridge MAC (matches Info.mac) parsed from the advertised name."""
+        hexpart, _ = self._parts()
+        return ":".join(hexpart[i : i + 2] for i in range(0, 12, 2)) if hexpart else ""
+
+    @property
+    def device_name(self) -> str:
+        """User-assigned name (espbridge set-name), "" when unset."""
+        return self._parts()[1]
+
+
+def _require_bleak():
+    try:
+        import bleak  # noqa: F401
+    except ImportError:
+        raise BridgeError(
+            "the Bluetooth transport needs the 'bleak' package — "
+            "install with: pip install python-esp-bridge[ble]"
+        ) from None
+
+
+def find_ble_devices(timeout: float = 5.0) -> list[BleDeviceInfo]:
+    """Scan for bridges advertising the BLE link service."""
+    _require_bleak()
+    import asyncio
+
+    from bleak import BleakScanner
+
+    async def _scan():
+        found = await BleakScanner.discover(
+            timeout=timeout, return_adv=True,
+            service_uuids=[BLE_LINK_SERVICE_UUID],
+        )
+        return [
+            BleDeviceInfo(dev.name or "", dev.address, adv.rssi)
+            for dev, adv in found.values()
+        ]
+
+    return asyncio.run(_scan())
+
+
+class BleTransport:
+    """BLE GATT transport with the same blocking interface as SerialTransport."""
+
+    has_baud = False    # wireless: no baud negotiation
+    needs_auth = True   # firmware requires SYS_AUTH before other commands
+    usb_chip = None
+
+    def __init__(self, address: str, *, connect_timeout: float = 10.0):
+        _require_bleak()
+        import asyncio
+
+        self.address = address
+        self._rx: queue.Queue[bytes] = queue.Queue()
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(target=self._loop.run_forever,
+                                        daemon=True, name="espbridge-ble")
+        self._thread.start()
+        self._client = None
+        try:
+            self._run(self._connect(address, connect_timeout), connect_timeout + 5)
+        except BaseException:
+            self._stop_loop()
+            raise
+
+    def _run(self, coro, timeout: float):
+        import asyncio
+
+        fut = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return fut.result(timeout)
+
+    async def _connect(self, address: str, timeout: float) -> None:
+        import asyncio
+
+        from bleak import BleakClient
+        from bleak.exc import BleakError
+
+        client = BleakClient(address, timeout=timeout)
+        try:
+            await client.connect()
+            await client.start_notify(BLE_LINK_TX_UUID, self._on_notify)
+        except BleakError as e:
+            raise NoDeviceError(f"BLE connect to {address} failed: {e}") from None
+        self._client = client
+        self._rx_char = client.services.get_characteristic(BLE_LINK_RX_UUID)
+        # The write-without-response limit starts at 20 and jumps after the
+        # MTU exchange (bleak docs); wait briefly so frames are not shredded
+        # into 20-byte writes during the handshake.
+        for _ in range(20):
+            if self._rx_char.max_write_without_response_size > 20:
+                break
+            await asyncio.sleep(0.1)
+
+    def _on_notify(self, _char, data: bytearray) -> None:
+        self._rx.put(bytes(data))
+
+    async def _write(self, data: bytes) -> None:
+        # Re-read per write: the limit can grow once the MTU exchange lands.
+        chunk = max(20, self._rx_char.max_write_without_response_size)
+        for i in range(0, len(data), chunk):
+            await self._client.write_gatt_char(
+                self._rx_char, data[i : i + chunk], response=False)
+
+    async def _disconnect(self) -> None:
+        if self._client is not None:
+            try:
+                await self._client.disconnect()
+            except Exception:
+                pass
+
+    def read(self) -> bytes:
+        try:
+            return self._rx.get(timeout=0.05)
+        except queue.Empty:
+            return b""
+
+    def write(self, data: bytes) -> None:
+        self._run(self._write(data), timeout=10.0)
+
+    def set_baudrate(self, baud: int) -> None:
+        pass  # wireless
+
+    def pulse_reset(self) -> None:
+        pass  # no DTR/RTS lines over the air
+
+    def _stop_loop(self) -> None:
+        self._loop.call_soon_threadsafe(self._loop.stop)
+        self._thread.join(timeout=2.0)
+
+    def close(self) -> None:
+        try:
+            self._run(self._disconnect(), timeout=5.0)
+        except Exception:
+            pass
+        self._stop_loop()

python_esp_bridge-0.1.1/espbridge/transports/mock.py

@@ -0,0 +1,46 @@
+"""In-memory transport for hardware-free tests."""
+from __future__ import annotations
+
+
+class MockTransport:
+    """In-memory transport for hardware-free tests.
+
+    `responder(data: bytes)` is called with everything the host writes; it can
+    push firmware->host bytes back via `inject()`.
+    """
+
+    has_baud = True    # exercises the baud-upgrade code path in tests
+    needs_auth = False  # tests flip this to emulate the wireless link
+
+    def __init__(self, responder=None):
+        import queue
+
+        self.usb_chip = None
+        self._rx: queue.Queue[bytes] = queue.Queue()
+        self.responder = responder
+        self.closed = False
+        self.baud = 115200
+
+    def inject(self, data: bytes) -> None:
+        self._rx.put(data)
+
+    def read(self) -> bytes:
+        import queue
+
+        try:
+            return self._rx.get(timeout=0.05)
+        except queue.Empty:
+            return b""
+
+    def write(self, data: bytes) -> None:
+        if self.responder is not None:
+            self.responder(data)
+
+    def set_baudrate(self, baud: int) -> None:
+        self.baud = baud
+
+    def pulse_reset(self) -> None:
+        pass
+
+    def close(self) -> None:
+        self.closed = True