python-broadlink 1.0.4__tar.gz → 1.0.6__tar.gz

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/CHANGELOG.md

@@ -3,6 +3,68 @@
 All notable changes to this project are recorded here. The format follows
 Keep a Changelog; versions follow Semantic Versioning.
 
+## 1.0.6 - 2026-09-06
+
+Small items from a sixth review, of 1.0.5, which found no defect in the
+code. No change to the wire format or the public API.
+
+### Fixed
+
+- A network failure during the library's own re-authentication (a timeout,
+  or the endpoint being closed) is raised as that failure. 1.0.3 to 1.0.5
+  returned the device's original expired-key answer instead, so the caller
+  raised `AuthorizationError` for what was really a timeout.
+- An endpoint with no address on either side (discovery, `ping()`,
+  `setup()`) is bound to `0.0.0.0` explicitly, for the proactor loop on
+  Windows, which starts receiving as soon as the endpoint exists.
+- The RM Max comment and the 1.0.0 changelog entry no longer claim more
+  than upstream #838 showed: the mapping follows that pull request's diff,
+  and its testers reported the device answering "locked" on
+  authentication, so it is listed as reported, not confirmed.
+
+### Changed
+
+- An undecodable capture is logged at debug rather than warning, since the
+  window re-arms and carries on by itself.
+- The RF capture loop closes its inner generator with `aclosing` like the
+  IR one.
+
+## 1.0.5 - 2026-09-06
+
+Fixes from a fifth review, of 1.0.4. No change to the wire format or the
+public API.
+
+### Fixed
+
+- A connected socket can learn from ICMP that a host cannot be reached
+  (`EHOSTUNREACH`, typically a router answering for a device that is off),
+  and 1.0.4 raised that as an `OSError` at once. The original library's
+  unconnected socket never saw it and simply timed out, and Home
+  Assistant tolerates a timeout for a few polls where it marks a device
+  unavailable on the first `OSError`. Host unreachable, and Windows's
+  `ConnectionResetError` for port unreachable, are now treated as silence
+  like port unreachable already was: logged, the timeout decides, and the
+  socket is still dropped afterwards. Measured on the bench first: on the
+  test network neither an on-link address with no host behind it nor an
+  off-subnet one produced the ICMP, so this is insurance for networks
+  that do, not a fix for one that reproduced.
+- `discover()` closes the `xdiscover()` generator it drains, like
+  `hello()` and `xdiscover()` itself.
+
+### Changed
+
+- The capture window claim is a flag set on the window's first iteration
+  and cleared when its generator finishes or is closed, including by
+  asyncio's finalizer, in place of the weak reference and frame
+  inspection used since 1.0.0. Same behaviour, pinned by the same tests:
+  a dropped window gets one turn to be finalized and then blocks nobody,
+  a held or paused window is refused to a newcomer. One visible
+  difference: `CaptureInProgressError` now always comes from the new
+  window's first iteration, never from the `capture()` call itself.
+- A comment next to the RM Max entry says why it sits in `rmpro`
+  (upstream #838's text says rm4pro, its tested diff says rmpro).
+- README: a device belongs to the event loop it first talks on.
+
 ## 1.0.4 - 2026-09-06
 
 Fixes from a fourth review, of 1.0.3, which drove the real socket path the
@@ -278,16 +340,17 @@ history below starts at that fork point.
   byte.
 - Devices, carried over from pull requests against the original repository
   with their authors credited (the changes were squash-merged with
-  `Co-authored-by` trailers naming each author): RM Max 0xAF8B (#838, Alexey Masolov);
-  RM5 plus 0x5224 with a new `rm5plus` class (#831, Anil Daoud); RM mini 3
+  `Co-authored-by` trailers naming each author): RM5 plus 0x5224 with a new `rm5plus` class (#831, Anil Daoud); RM mini 3
   OEM 0xA544 (#823, Bartłomiej Nogaś); RM mini 3 CMCC 0x27C8 (#802,
   shuxin); LB26 R1 0xA517 (#812, techitapart); SP mini 3-AL 0x7D15 (#805,
   bbcbbk); LEDVANCE SMART+ WIFI CEILING TW 24W 0x6498 (#799, Felipe Martins
   Diel).
 - Devices reported in issues against the original repository, added by
   model name to the existing class for that family and not yet confirmed on
-  hardware: MP1-1K3S2U 0x4EDA (#816) and SP4 0xA57A (#758). Please open an
-  issue if either does not behave.
+  hardware: MP1-1K3S2U 0x4EDA (#816) and SP4 0xA57A (#758), and the RM Max
+  0xAF8B from #838 (Alexey Masolov, credited), whose testers reported the
+  device answering "locked" on authentication. Please open an issue if any
+  of them does not behave.
 - `cryptography` 43 or newer is required, the first release with wheels for
   Python 3.13 (supersedes mjg59/python-broadlink#749).
 - A test suite. The `tests/oracle` package records, for every public method

{python_broadlink-1.0.4/python_broadlink.egg-info → python_broadlink-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.4
+Version: 1.0.6
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -236,6 +236,11 @@ async with device:
 await device.aclose()
 ```
 
+A device belongs to the event loop it first talks on: its socket and its
+locks are bound to that loop, so a script that runs several
+`asyncio.run(...)` calls should create the device inside each one rather
+than reuse it across them.
+
 The socket reopens by itself on the next call, so closing is cheap and
 safe to do at any time. A request that is in flight when `aclose()` runs
 fails with `EndpointClosedError`. A request that fails for a network
@@ -321,9 +326,8 @@ By default the window closes after the first signal. Pass
 because the device holds only one code per learning session. A universal
 remote has a single receiver, so only one capture window can be open on a
 device at a time: opening a second one raises `CaptureInProgressError`
-while the first is still held, either from the `capture()` call itself or
-from the new window's first iteration, depending on what the first window
-was doing at that moment. Always close a window you leave early
+from the new window's first iteration while the first is still held.
+Always close a window you leave early
 (`aclosing` above does it), otherwise it stays open until Python collects
 the generator.
 

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/README.md

@@ -205,6 +205,11 @@ async with device:
 await device.aclose()
 ```
 
+A device belongs to the event loop it first talks on: its socket and its
+locks are bound to that loop, so a script that runs several
+`asyncio.run(...)` calls should create the device inside each one rather
+than reuse it across them.
+
 The socket reopens by itself on the next call, so closing is cheap and
 safe to do at any time. A request that is in flight when `aclose()` runs
 fails with `EndpointClosedError`. A request that fails for a network
@@ -290,9 +295,8 @@ By default the window closes after the first signal. Pass
 because the device holds only one code per learning session. A universal
 remote has a single receiver, so only one capture window can be open on a
 device at a time: opening a second one raises `CaptureInProgressError`
-while the first is still held, either from the `capture()` call itself or
-from the new window's first iteration, depending on what the first window
-was doing at that moment. Always close a window you leave early
+from the new window's first iteration while the first is still held.
+Always close a window you leave early
 (`aclosing` above does it), otherwise it stays open until Python collects
 the generator.
 

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/broadlink/__init__.py

@@ -116,6 +116,9 @@ SUPPORTED_TYPES = {
         0x27A6: ("RM plus", "Broadlink"),
         0x27A9: ("RM pro+", "Broadlink"),
         0x27C3: ("RM pro+", "Broadlink"),
+        # Mapping follows the diff in upstream #838 (its text says rm4pro,
+        # its diff says rmpro). Testers in that thread reported the device
+        # answering "locked" on auth, so treat it as reported, not confirmed.
         0xAF8B: ("RM Max", "Broadlink"),
     },
     rmminib: {
@@ -281,12 +284,9 @@ async def discover(
     discover_ip_port: int = DEFAULT_PORT,
 ) -> list[Device]:
     """Discover devices connected to the local network."""
-    return [
-        device
-        async for device in xdiscover(
-            timeout, local_ip_address, discover_ip_address, discover_ip_port
-        )
-    ]
+    devices = xdiscover(timeout, local_ip_address, discover_ip_address, discover_ip_port)
+    async with contextlib.aclosing(devices):
+        return [device async for device in devices]
 
 
 async def xdiscover(

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/broadlink/device.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import asyncio
 import collections
 import contextlib
+import errno
 import logging
 import random
 import socket
@@ -53,6 +54,22 @@ _QueueItem = tuple[bytes | Exception | None, tuple[str, int] | None]
 error the socket reported (address ``None``), or ``_CLOSED``."""
 
 
+def _is_silence(item: object) -> bool:
+    """True for the socket errors that mean "no device answered".
+
+    A connected datagram socket learns from ICMP that nobody is listening
+    (port unreachable, ``ConnectionRefusedError``; ``ConnectionResetError``
+    on Windows) or that the host cannot be reached (``EHOSTUNREACH``, from
+    a router answering for a host that is off). The original library used
+    an unconnected socket that never received any of these and simply
+    timed out, and callers such as Home Assistant treat a timeout more
+    leniently than an ``OSError``, so these are treated as silence.
+    """
+    if isinstance(item, ConnectionRefusedError | ConnectionResetError):
+        return True
+    return isinstance(item, OSError) and item.errno == errno.EHOSTUNREACH
+
+
 class _Protocol(asyncio.DatagramProtocol):
     """Datagram protocol that hands every received packet to a queue.
 
@@ -103,7 +120,14 @@ async def _open_endpoint(
     remote_addr: tuple[str, int] | None = None,
     broadcast: bool = False,
 ) -> tuple[asyncio.DatagramTransport, _Protocol]:
-    """Create a UDP endpoint. Tests replace this to fake the network."""
+    """Create a UDP endpoint. Tests replace this to fake the network.
+
+    An endpoint with no address on either side is bound to ``0.0.0.0``
+    explicitly; the proactor loop on Windows starts receiving as soon as the
+    endpoint exists, which needs a bound socket.
+    """
+    if local_addr is None and remote_addr is None:
+        local_addr = ("0.0.0.0", 0)
     loop = asyncio.get_running_loop()
     transport, protocol = await loop.create_datagram_endpoint(
         _Protocol,
@@ -570,12 +594,15 @@ class Device:
                     raise e.EndpointClosedError(
                         -4013, "Endpoint closed", "The device endpoint was closed"
                     )
-                if isinstance(resp, ConnectionRefusedError):
-                    # ICMP port unreachable: the host is up and nothing is
-                    # listening, or the device is rebooting. The original
-                    # library's unconnected socket never saw these, so keep
-                    # waiting and let the timeout decide, as it did.
-                    _LOGGER.debug("%s: port unreachable, still waiting", self.host[0])
+                if _is_silence(resp):
+                    # ICMP unreachable of one kind or another: the host is up
+                    # with nothing listening, the device is off or rebooting,
+                    # or a router answered for it. The original library's
+                    # unconnected socket never saw these, so keep waiting and
+                    # let the timeout decide, as it did.
+                    _LOGGER.debug(
+                        "%s: unreachable (%s), still waiting", self.host[0], resp
+                    )
                     continue
                 if isinstance(resp, Exception):
                     # A send failure (no route, address gone) or a fatal
@@ -623,6 +650,11 @@ class Device:
                 if self._auth_generation == generation:
                     try:
                         await self.auth()
+                    except (e.NetworkTimeoutError, e.EndpointClosedError):
+                        # A network failure during re-authentication is
+                        # reported as what it is, not as the device's
+                        # original expired-key answer.
+                        raise
                     except e.BroadlinkException as err:
                         _LOGGER.debug(
                             "%s: re-authentication failed: %s", self.host[0], err

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/broadlink/remote.py

@@ -1,11 +1,11 @@
 """Support for universal remotes."""
 
 import asyncio
+import contextlib
 import enum
 import logging
 import struct
 import time
-import weakref
 from collections.abc import AsyncGenerator, Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Self
@@ -221,51 +221,39 @@ class rmmini(Device):
         # against the value it saw when it armed the device and re-arms
         # after any send, since the device has one front end for both.
         self._tx_generation = 0
-        # Weak reference to the async generator of the current capture
-        # window, if any. See _claim_window.
-        self._window: weakref.ReferenceType | None = None
+        # True while a capture window holds the device's receiver. Set by
+        # the window on its first iteration, cleared when its generator
+        # finishes or is closed, including by asyncio's finalizer.
+        self._capturing = False
 
     @property
     def capture_active(self) -> bool:
         """True while a capture window is open on this device."""
-        window = self._window() if self._window is not None else None
-        return window is not None and window.ag_frame is not None
+        return self._capturing
 
-    def _check_window(self) -> None:
-        """Fail fast at call time if another window is being iterated now."""
-        old = self._window() if self._window is not None else None
-        if old is not None and old.ag_frame is not None and old.ag_running:
-            raise e.CaptureInProgressError("A capture window is already open")
-
-    async def _claim_window(self, new: weakref.ReferenceType) -> None:
-        """Make sure the previous window is really gone, then register ``new``.
+    async def _claim_window(self) -> None:
+        """Take the receiver for a new window, or refuse.
 
         A consumer that walked away from a window without closing it (for
         example ``break`` out of ``async for`` with no ``aclosing``) leaves
         the generator to asyncio's finalizer, which closes it on the next
-        loop iteration once nothing references it. Give that a turn. If the
-        window is still alive after that, someone still holds it, whether
-        they are inside ``__anext__`` or paused between signals, and the new
-        window is refused rather than taken from under them.
+        loop iteration once nothing references it, and closing it releases
+        the claim. Give that a turn. If the claim is still held after that,
+        someone still has the window, whether inside ``__anext__`` or
+        paused between signals, and the new window is refused rather than
+        taken from under them.
         """
-        prev = self._window
-        if prev is not None:
-            old = prev()
-            if old is not None and old.ag_frame is not None:
-                if old.ag_running:
-                    raise e.CaptureInProgressError("A capture window is already open")
-                del old  # Hold no reference while the finalizer gets its turn.
-                await asyncio.sleep(0)
-                await asyncio.sleep(0)
-                old = prev()
-                if old is not None and old.ag_frame is not None:
-                    raise e.CaptureInProgressError(
-                        "A capture window is already open; close it with aclose() first"
-                    )
-                if self._window is not prev:
-                    # Another claimant got in during the two turns above.
-                    raise e.CaptureInProgressError("A capture window is already open")
-        self._window = new
+        if self._capturing:
+            await asyncio.sleep(0)
+            await asyncio.sleep(0)
+            if self._capturing:
+                raise e.CaptureInProgressError(
+                    "A capture window is already open; close it with aclose() first"
+                )
+        self._capturing = True
+
+    def _release_window(self) -> None:
+        self._capturing = False
 
     async def _send(self, command: int, data: bytes = b"") -> bytes:
         """Send a packet to the device."""
@@ -319,13 +307,11 @@ class rmmini(Device):
         Use ``contextlib.aclosing`` (or iterate to the end) so the window is
         released promptly. Only one capture window can be open per device:
         opening one while another is still held raises
-        ``CaptureInProgressError``. A window whose generator was dropped
-        without being closed is finalized by asyncio on the next loop
-        iteration and does not block.
+        ``CaptureInProgressError`` on its first iteration. A window whose
+        generator was dropped without being closed is finalized by asyncio
+        on the next loop iteration and does not block.
         """
-        self._check_window()
-        holder: list = []
-        gen = self._capture_loop(
+        return self._capture_loop(
             self.enter_learning,
             window,
             stop_after_first,
@@ -333,10 +319,8 @@ class rmmini(Device):
             rearm_interval,
             SignalKind.IR,
             None,
-            claim=holder,
+            claim=True,
         )
-        holder.append(weakref.ref(gen))
-        return gen
 
     async def _capture_loop(
         self,
@@ -348,18 +332,43 @@ class rmmini(Device):
         kind: SignalKind,
         frequency_mhz: float | None,
         *,
-        claim: list | None = None,
+        claim: bool,
     ) -> AsyncGenerator[CapturedSignal]:
-        # ``claim`` carries a weak reference to this generator (filled in by
-        # the caller after creating it); None means the caller owns the
-        # window claim, as capture_rf does for its inner loop.
+        # ``claim`` is False when the caller already holds the window, as
+        # capture_rf does for its inner loop.
         if window < 0:
             raise ValueError("window must be 0 (open-ended) or positive")
         if poll_interval <= 0 or rearm_interval <= 0:
             raise ValueError("poll_interval and rearm_interval must be positive")
         if claim:
-            await self._claim_window(claim[0])
+            await self._claim_window()
+        try:
+            body = self._capture_body(
+                arm,
+                window,
+                stop_after_first,
+                poll_interval,
+                rearm_interval,
+                kind,
+                frequency_mhz,
+            )
+            async with contextlib.aclosing(body):
+                async for signal in body:
+                    yield signal
+        finally:
+            if claim:
+                self._release_window()
 
+    async def _capture_body(
+        self,
+        arm: Callable[[], Awaitable[None]],
+        window: float,
+        stop_after_first: bool,
+        poll_interval: float,
+        rearm_interval: float,
+        kind: SignalKind,
+        frequency_mhz: float | None,
+    ) -> AsyncGenerator[CapturedSignal]:
         loop = asyncio.get_running_loop()
         deadline = loop.time() + window if window else None
         timeouts = 0
@@ -399,7 +408,7 @@ class rmmini(Device):
                 except ValueError as err:
                     # A packet the device returned but we cannot decode. Log
                     # it, re-arm and keep the window open.
-                    _LOGGER.warning(
+                    _LOGGER.debug(
                         "%s: ignoring an undecodable capture (%s): %s",
                         self.host[0],
                         err,
@@ -475,18 +484,9 @@ class rmpro(rmmini):
         Each ``CapturedSignal`` carries the carrier in ``frequency_mhz``,
         which the packet itself does not record.
         """
-        self._check_window()
-        holder: list = []
-        gen = self._capture_rf_loop(
-            window,
-            frequency,
-            stop_after_first,
-            poll_interval,
-            rearm_interval,
-            claim=holder,
+        return self._capture_rf_loop(
+            window, frequency, stop_after_first, poll_interval, rearm_interval
         )
-        holder.append(weakref.ref(gen))
-        return gen
 
     async def _capture_rf_loop(
         self,
@@ -495,13 +495,28 @@ class rmpro(rmmini):
         stop_after_first: bool,
         poll_interval: float,
         rearm_interval: float,
-        *,
-        claim: list,
     ) -> AsyncGenerator[CapturedSignal]:
         if window < 0 or poll_interval <= 0:
             raise ValueError("window must be 0 or positive, poll_interval positive")
-        await self._claim_window(claim[0])
+        await self._claim_window()
+        try:
+            body = self._capture_rf_body(
+                window, frequency, stop_after_first, poll_interval, rearm_interval
+            )
+            async with contextlib.aclosing(body):
+                async for signal in body:
+                    yield signal
+        finally:
+            self._release_window()
 
+    async def _capture_rf_body(
+        self,
+        window: float,
+        frequency: float | None,
+        stop_after_first: bool,
+        poll_interval: float,
+        rearm_interval: float,
+    ) -> AsyncGenerator[CapturedSignal]:
         loop = asyncio.get_running_loop()
         deadline = loop.time() + window if window else None
 
@@ -526,13 +541,11 @@ class rmpro(rmmini):
             rearm_interval,
             kind,
             frequency,
-            claim=None,
+            claim=False,
         )
-        try:
+        async with contextlib.aclosing(inner):
             async for signal in inner:
                 yield signal
-        finally:
-            await inner.aclose()
 
     async def _sweep(self, deadline: float | None, poll_interval: float) -> float | None:
         """Sweep for the remote's carrier; return it in MHz, or None if the

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-broadlink"
-version = "1.0.4"
+version = "1.0.6"
 description = "Python API for controlling Broadlink devices"
 readme = "README.md"
 license = "MIT"

{python_broadlink-1.0.4 → python_broadlink-1.0.6/python_broadlink.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.4
+Version: 1.0.6
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -236,6 +236,11 @@ async with device:
 await device.aclose()
 ```
 
+A device belongs to the event loop it first talks on: its socket and its
+locks are bound to that loop, so a script that runs several
+`asyncio.run(...)` calls should create the device inside each one rather
+than reuse it across them.
+
 The socket reopens by itself on the next call, so closing is cheap and
 safe to do at any time. A request that is in flight when `aclose()` runs
 fails with `EndpointClosedError`. A request that fails for a network
@@ -321,9 +326,8 @@ By default the window closes after the first signal. Pass
 because the device holds only one code per learning session. A universal
 remote has a single receiver, so only one capture window can be open on a
 device at a time: opening a second one raises `CaptureInProgressError`
-while the first is still held, either from the `capture()` call itself or
-from the new window's first iteration, depending on what the first window
-was doing at that moment. Always close a window you leave early
+from the new window's first iteration while the first is still held.
+Always close a window you leave early
 (`aclosing` above does it), otherwise it stays open until Python collects
 the generator.
 

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/tests/test_loopback.py

@@ -107,4 +107,20 @@ def test_endpoint_heals_after_a_socket_error_on_loopback(caplog):
             await dev.aclose()
 
     assert asyncio.run(go()) == 9
-    assert "port unreachable" in caplog.text
+    assert "unreachable" in caplog.text
+
+
+def test_unbound_endpoint_is_bound_explicitly():
+    """scan, ping and setup open an endpoint with no address on either
+    side; it is bound to 0.0.0.0 so it can receive on every platform."""
+
+    async def go():
+        transport, _ = await device_module._open_endpoint(broadcast=True)
+        try:
+            host, port = transport.get_extra_info("sockname")[:2]
+            return host, port
+        finally:
+            transport.close()
+
+    host, port = asyncio.run(go())
+    assert host == "0.0.0.0" and port > 0

{python_broadlink-1.0.4 → python_broadlink-1.0.6}/tests/test_transport.py

@@ -483,6 +483,40 @@ def test_send_failure_fails_the_request_fast_and_heals(net):
     assert run(go())
 
 
+@pytest.mark.parametrize(
+    "err",
+    [
+        ConnectionRefusedError(111, "Connection refused"),
+        ConnectionResetError(10054, "Connection reset"),
+        OSError(113, "No route to host"),
+    ],
+    ids=["port-unreachable", "windows-reset", "host-unreachable"],
+)
+def test_icmp_unreachable_is_silence_not_an_error(net, err):
+    """0.19.0's unconnected socket never saw ICMP errors: a device that was
+    off, rebooting, or behind a router answering for it produced silence
+    and then NetworkTimeoutError, which Home Assistant tolerates for a few
+    polls where it would mark the device unavailable on an OSError. The
+    connected socket must keep that contract."""
+    dev = fixed_device()
+    dev.timeout = 0.05
+
+    async def go():
+        await dev._endpoint()
+        ep = net.endpoints[-1]
+
+        def icmp_sendto(data, addr=None):
+            ep.protocol.error_received(err)
+
+        ep.sendto = icmp_sendto
+        with pytest.raises(e.NetworkTimeoutError):
+            await dev.send_packet(0x6A, b"")
+        assert ep.closed  # dropped after the timeout, so the next call heals
+        assert dev._transport is None
+
+    run(go())
+
+
 def test_transport_lost_with_error_wakes_the_request(net):
     """If asyncio closes the transport from its side, the waiting request
     is told instead of waiting out its timeout."""
@@ -597,6 +631,25 @@ def test_failed_reauth_returns_the_original_reply(net):
         e.check_error(resp[0x22:0x24])
 
 
+def test_timeout_during_reauth_is_reported_as_a_timeout(net):
+    """If the device answers the request with an expired-key code and then
+    goes silent during the re-authentication, that is a network failure and
+    is raised as one, not returned as the device's original answer."""
+    dev = fixed_device()
+    dev.timeout = 0.03
+
+    async def go():
+        await dev._endpoint()
+        ep = net.endpoints[-1]
+        ep.replies = [(make_response(dev, b"", error=0xFFF9), HOST)]  # then silence
+        with pytest.raises(e.NetworkTimeoutError):
+            await dev.send_packet(0x6A, b"")
+        return [int.from_bytes(f[0x26:0x28], "little") for f, _ in ep.sent]
+
+    types = run(go())
+    assert types[0] == 0x6A and set(types[1:]) == {0x65}  # auth was tried and resent
+
+
 def test_locked_device_surfaces_as_the_original_error(net):
     """Device locked in the app: request answered -7, auth answered -1. The
     caller gets the -7 frame back (its check_error raises