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

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

@@ -3,6 +3,104 @@
 All notable changes to this project are recorded here. The format follows
 Keep a Changelog; versions follow Semantic Versioning.
 
+## 1.0.4 - 2026-09-06
+
+Fixes from a fourth review, of 1.0.3, which drove the real socket path the
+test suite fakes and found two behaviours the original library had and
+this one had lost. One device fix carried from upstream.
+
+### Fixed
+
+- A connected socket that went bad (interface bounce, host address change,
+  container network restart) was never replaced: the request waited out
+  its timeout and every later request did the same until `aclose()`. The
+  original opened a socket per call, so it healed on the next one. Now a
+  send failure the socket reports (no route, address gone) fails the
+  waiting request at once with that `OSError`, and a request that fails
+  for a network reason (that, or a timeout) drops the socket so the next
+  call opens a fresh one. A transport asyncio closes from its side also
+  wakes the waiting request instead of leaving it to time out. An ICMP
+  "port unreachable" (a host that is up with nothing listening, or a
+  device mid-reboot) is logged and treated as silence, since the
+  original's unconnected socket never saw those, so the timeout decides
+  as before.
+- `discover()`, `hello()`, `ping()` and `setup()` passed hostnames straight
+  to `sendto`, which resolved them with a blocking call on the event loop
+  and swallowed the failure: a name that did not resolve made `hello()`
+  wait out its timeout and `ping()` return without sending. The
+  destination is now resolved once, off the loop, and `socket.gaierror`
+  propagates as it did from the original's socket. A send failure in
+  `ping()` and `setup()` is raised too.
+- The A2 air quality sensor's request frame was two bytes short and
+  declared the wrong length, and real units answered every read with
+  error -5. The frame now follows the SP4/LB1 layout, which is byte for
+  byte the packet upstream pull request #826 tested on an A2. That is the
+  one oracle case re-recorded on purpose; the fix is carried on the
+  strength of that report, not of hardware we have.
+- `xdiscover()` closes the `scan()` generator it wraps, so the discovery
+  socket is closed when the caller stops iterating rather than by the
+  finalizer a few turns later (1.0.2 claimed this and only `Device.hello()`
+  did it).
+- Two identical captures compare equal: `CapturedSignal.captured_at` no
+  longer takes part in equality or hashing.
+- Async generator functions are annotated `AsyncGenerator`, which has the
+  `aclose()` the library and the README call; `AsyncIterator` does not.
+- The `TICK` docstring tells the same story as the README: 8192/269 from
+  protocol.md's measured conversion, not a 32768 Hz clock.
+
+### Added
+
+- A loopback test module that drives the real datagram endpoint, including
+  the socket-error path, since every other transport test fakes it.
+- README: which errors `discover()` and `hello()` raise, that a failed
+  request drops its socket, and that `CaptureInProgressError` can come
+  from the `capture()` call or from the first iteration.
+
+## 1.0.3 - 2026-09-06
+
+Fixes from a third review, this one of 1.0.2. No change to the wire
+format. One small API change: `pulses` on a captured signal is a tuple.
+
+### Fixed
+
+- When the device answered that the session key had expired and the
+  re-authentication then failed (for example because the device had been
+  locked in the app), the call raised `AuthenticationError` from the
+  re-authentication instead of the error the device gave the request. The
+  original library never re-authenticated, so a program written against
+  it, Home Assistant's integration included, handles the request's own
+  error and never expected the other one. The failed re-authentication is
+  now logged and the request's original reply is returned, so the caller
+  sees the same `AuthorizationError` or `ConnectionClosedError` it always
+  did.
+- The authentication generation was read before the request lock was
+  taken rather than under it, so a request queued behind an `auth()`
+  could observe a stale generation and skip a re-authentication it needed.
+- `aclose()` racing an endpoint that was still being opened could leave
+  the new socket open and unreferenced. The open now notices the close
+  and fails with `EndpointClosedError`.
+- After a new capture window gives the finalizer its turn, it re-checks
+  that no other window claimed the device in the meantime.
+- `CapturedSignal` and `ParsedPacket` are frozen dataclasses, but they
+  held a list, so they could not be hashed or put in a set. `pulses` is
+  now a `tuple[int, ...]`.
+- `check_error` unpacks the error code as little-endian explicitly
+  (`"<h"`), matching the rest of the code, instead of native order.
+- The CLI closes the device it opens instead of leaving that to
+  `asyncio.run`, which warned under `python -X dev`.
+- The locks are created in `__init__` rather than lazily in two places.
+
+### Changed
+
+- `send_packet` accepts a `bytearray` payload as well as `bytes`.
+- `setup()` sends its provisioning packet through a new
+  `send_setup_packet()` helper in `broadlink.device` instead of reaching
+  into a private function.
+- README: the re-authentication contract and its worst case (one call can
+  wait out up to three timeouts), the A2 sensor and the Hysen HY02/HY03
+  in the device list, and the hello response's `mac` being `bytes` in the
+  list of differences from 0.19.0.
+
 ## 1.0.2 - 2026-09-05
 
 Fixes from a second, adversarial review of 1.0.1 and a re-test of the

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.2
+Version: 1.0.4
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -51,8 +51,9 @@ Every call that reaches a device is a coroutine and must be awaited. That
 is the main change from the original library's API: method names and
 arguments are the same, and so are return values, with the small
 exceptions listed in `CHANGELOG.md` (the IR tick constant, `pulses_to_data`
-returning `bytes`, the unused `Device.lock` attribute removed, and
-`timeout` parameters typed as floats).
+returning `bytes`, the unused `Device.lock` attribute removed, `timeout`
+parameters typed as floats, and the `mac` in a hello response typed as
+`bytes`).
 
 ```python
 import asyncio
@@ -81,11 +82,11 @@ The following devices are supported:
 - **Switches**: MCB1, SC1, SCB1E, SCB2
 - **Outlets**: BG 800, BG 900
 - **Power strips**: MP1-1K3S2U, MP1-1K4S, MP2
-- **Environment sensors**: A1
+- **Environment sensors**: A1, A2
 - **Alarm kits**: S1C, S2KIT
 - **Light bulbs**: LB1, LB26 R1, LB27 R1, SB800TD, LEDVANCE SMART+ WIFI CEILING TW 24W
 - **Curtain motors**: Dooya DT360E-45/20
-- **Thermostats**: Hysen HY02B05H
+- **Thermostats**: Hysen HY02/HY03
 - **Hubs**: S3
 
 ## Timing
@@ -192,6 +193,11 @@ If the device is locked, it may not be discoverable with broadcast. In such case
 device = await broadlink.hello("192.168.0.16")
 ```
 
+`discover()` and `hello()` raise `NetworkTimeoutError` when nothing answers
+within the timeout, `socket.gaierror` when a hostname does not resolve, and
+`OSError` when the socket cannot be opened or the send fails (no route, for
+example), the same errors the original library raised from its socket.
+
 If you are a perfomance freak, use `broadlink.xdiscover()` to create devices instantly:
 ```python3
 async for device in broadlink.xdiscover():
@@ -204,6 +210,17 @@ After discovering the device, call the `auth()` method to obtain the authenticat
 await device.auth()
 ```
 
+The session key expires on the device after a while. When a request comes
+back with an expired-key answer, the library authenticates again and
+repeats the request once, so a long-running program does not need to
+handle that itself. If the second authentication fails, for example
+because the device was locked in the app in the meantime, the call raises
+the error the device gave the first time, the same `AuthorizationError`
+or `ConnectionClosedError` the original library raised, and it is up to
+the caller to decide what to do. In the worst case one call can wait out
+three timeouts (the request, the authentication, and the repeat), each
+bounded by `device.timeout`.
+
 ### Closing
 
 Each device keeps one UDP socket open for its lifetime (the original
@@ -221,9 +238,14 @@ await device.aclose()
 
 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`. An integration that creates devices
-should close them when it unloads; a device that is never closed holds
-its socket until it is garbage collected.
+fails with `EndpointClosedError`. A request that fails for a network
+reason (a timeout, or an `OSError` from the socket such as "network is
+unreachable" after an interface change, raised at once) also drops the socket, so the
+next call starts fresh rather than reusing one that has gone bad, which
+is how the original library behaved by opening a socket per call. An
+integration that creates devices should close them when it unloads; a
+device that is never closed holds its socket until it is garbage
+collected.
 
 The next steps depend on the type of device you want to control.
 
@@ -299,7 +321,9 @@ 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. Always close a window you leave early
+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
 (`aclosing` above does it), otherwise it stays open until Python collects
 the generator.
 

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

@@ -20,8 +20,9 @@ Every call that reaches a device is a coroutine and must be awaited. That
 is the main change from the original library's API: method names and
 arguments are the same, and so are return values, with the small
 exceptions listed in `CHANGELOG.md` (the IR tick constant, `pulses_to_data`
-returning `bytes`, the unused `Device.lock` attribute removed, and
-`timeout` parameters typed as floats).
+returning `bytes`, the unused `Device.lock` attribute removed, `timeout`
+parameters typed as floats, and the `mac` in a hello response typed as
+`bytes`).
 
 ```python
 import asyncio
@@ -50,11 +51,11 @@ The following devices are supported:
 - **Switches**: MCB1, SC1, SCB1E, SCB2
 - **Outlets**: BG 800, BG 900
 - **Power strips**: MP1-1K3S2U, MP1-1K4S, MP2
-- **Environment sensors**: A1
+- **Environment sensors**: A1, A2
 - **Alarm kits**: S1C, S2KIT
 - **Light bulbs**: LB1, LB26 R1, LB27 R1, SB800TD, LEDVANCE SMART+ WIFI CEILING TW 24W
 - **Curtain motors**: Dooya DT360E-45/20
-- **Thermostats**: Hysen HY02B05H
+- **Thermostats**: Hysen HY02/HY03
 - **Hubs**: S3
 
 ## Timing
@@ -161,6 +162,11 @@ If the device is locked, it may not be discoverable with broadcast. In such case
 device = await broadlink.hello("192.168.0.16")
 ```
 
+`discover()` and `hello()` raise `NetworkTimeoutError` when nothing answers
+within the timeout, `socket.gaierror` when a hostname does not resolve, and
+`OSError` when the socket cannot be opened or the send fails (no route, for
+example), the same errors the original library raised from its socket.
+
 If you are a perfomance freak, use `broadlink.xdiscover()` to create devices instantly:
 ```python3
 async for device in broadlink.xdiscover():
@@ -173,6 +179,17 @@ After discovering the device, call the `auth()` method to obtain the authenticat
 await device.auth()
 ```
 
+The session key expires on the device after a while. When a request comes
+back with an expired-key answer, the library authenticates again and
+repeats the request once, so a long-running program does not need to
+handle that itself. If the second authentication fails, for example
+because the device was locked in the app in the meantime, the call raises
+the error the device gave the first time, the same `AuthorizationError`
+or `ConnectionClosedError` the original library raised, and it is up to
+the caller to decide what to do. In the worst case one call can wait out
+three timeouts (the request, the authentication, and the repeat), each
+bounded by `device.timeout`.
+
 ### Closing
 
 Each device keeps one UDP socket open for its lifetime (the original
@@ -190,9 +207,14 @@ await device.aclose()
 
 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`. An integration that creates devices
-should close them when it unloads; a device that is never closed holds
-its socket until it is garbage collected.
+fails with `EndpointClosedError`. A request that fails for a network
+reason (a timeout, or an `OSError` from the socket such as "network is
+unreachable" after an interface change, raised at once) also drops the socket, so the
+next call starts fresh rather than reusing one that has gone bad, which
+is how the original library behaved by opening a socket per call. An
+integration that creates devices should close them when it unloads; a
+device that is never closed holds its socket until it is garbage
+collected.
 
 The next steps depend on the type of device you want to control.
 
@@ -268,7 +290,9 @@ 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. Always close a window you leave early
+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
 (`aclosing` above does it), otherwise it stays open until Python collects
 the generator.
 

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

@@ -1,16 +1,14 @@
-#!/usr/bin/env python3
 """The python-broadlink library."""
 
 import contextlib
-from collections.abc import AsyncIterator
-from typing import Optional, Union
+from collections.abc import AsyncGenerator
 
 from . import exceptions as e
 from .alarm import S1C
 from .climate import hvac, hysen
 from .const import DEFAULT_BCAST_ADDR, DEFAULT_PORT, DEFAULT_TIMEOUT
 from .cover import dooya, dooya2, wser
-from .device import Device, _open_endpoint, ping, scan
+from .device import Device, ping, scan, send_setup_packet
 from .hub import s3
 from .light import lb1, lb2
 from .remote import rm, rm4, rm4mini, rm4pro, rm5plus, rmmini, rmminib, rmpro
@@ -296,15 +294,15 @@ async def xdiscover(
     local_ip_address: str | None = None,
     discover_ip_address: str = DEFAULT_BCAST_ADDR,
     discover_ip_port: int = DEFAULT_PORT,
-) -> AsyncIterator[Device]:
+) -> AsyncGenerator[Device]:
     """Discover devices connected to the local network.
 
     Yields each device as soon as it answers.
     """
-    async for resp in scan(
-        timeout, local_ip_address, discover_ip_address, discover_ip_port
-    ):
-        yield gendevice(*resp)
+    responses = scan(timeout, local_ip_address, discover_ip_address, discover_ip_port)
+    async with contextlib.aclosing(responses):
+        async for resp in responses:
+            yield gendevice(*resp)
 
 
 # Setup a new Broadlink device via AP Mode. Review the README to see how to enter AP Mode.
@@ -340,8 +338,4 @@ async def setup(
     payload[0x20] = checksum & 0xFF  # Checksum 1 position
     payload[0x21] = checksum >> 8  # Checksum 2 position
 
-    transport, _ = await _open_endpoint(broadcast=True)
-    try:
-        transport.sendto(payload, (ip_address, DEFAULT_PORT))
-    finally:
-        transport.close()
+    await send_setup_packet(bytes(payload), ip_address)

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

@@ -15,7 +15,7 @@ import contextlib
 import logging
 import random
 import socket
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
@@ -48,33 +48,55 @@ _RECENT_MAX = 64
 _CLOSED = (None, None)
 """Sentinel put on the receive queue when the endpoint is closed."""
 
+_QueueItem = tuple[bytes | Exception | None, tuple[str, int] | None]
+"""What the receive queue carries: a datagram with its source address, an
+error the socket reported (address ``None``), or ``_CLOSED``."""
+
 
 class _Protocol(asyncio.DatagramProtocol):
-    """Datagram protocol that hands every received packet to a queue."""
+    """Datagram protocol that hands every received packet to a queue.
+
+    Errors the socket reports go on the same queue, so the request that is
+    waiting fails at once instead of waiting out its timeout.
+    """
 
     def __init__(self) -> None:
-        self.queue: asyncio.Queue[tuple[bytes, tuple[str, int]]] = asyncio.Queue()
+        self.queue: asyncio.Queue[_QueueItem] = asyncio.Queue()
         self.transport: asyncio.DatagramTransport | None = None
 
-    def connection_made(self, transport) -> None:  # type: ignore[override]
-        self.transport = transport
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        """Keep the transport; the endpoint sends through it."""
+        self.transport = transport  # type: ignore[assignment]
 
     def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
+        """Queue every datagram for the request that is waiting."""
         self.queue.put_nowait((data, addr))
 
     def error_received(self, exc: Exception) -> None:
-        # ICMP unreachable and the like. Surface it as a receive of nothing;
-        # the retry loop will time out and raise NetworkTimeoutError.
-        pass
+        """Queue a send failure or an ICMP error for the waiting request."""
+        self.queue.put_nowait((exc, None))
 
     def connection_lost(self, exc: Exception | None) -> None:
-        pass
+        """Wake the waiting request if asyncio closed the transport on us."""
+        self.queue.put_nowait((exc, None) if exc is not None else _CLOSED)
 
     def drain(self) -> None:
         """Drop anything that arrived before the current request."""
         while not self.queue.empty():
             self.queue.get_nowait()
 
+    def raise_if_error(self) -> None:
+        """Raise the error a send just reported, if it reported one.
+
+        asyncio delivers a failed ``sendto`` to ``error_received`` before
+        ``sendto`` returns, so a fire-and-forget sender can check right
+        after sending and raise the ``OSError`` the way a plain socket did.
+        """
+        while not self.queue.empty():
+            item, _ = self.queue.get_nowait()
+            if isinstance(item, Exception):
+                raise item
+
 
 async def _open_endpoint(
     local_addr: tuple[str, int] | None = None,
@@ -93,6 +115,21 @@ async def _open_endpoint(
     return transport, protocol  # type: ignore[return-value]
 
 
+async def _resolve(host: str, port: int) -> tuple[str, int]:
+    """Resolve a destination once, off the event loop.
+
+    Sending to a hostname through an unconnected datagram socket would
+    resolve it with a blocking call on the loop and hide the failure. A
+    name that does not resolve raises ``socket.gaierror`` here, as the
+    original library's ``sendto`` did.
+    """
+    loop = asyncio.get_running_loop()
+    info = await loop.getaddrinfo(
+        host, port, family=socket.AF_INET, type=socket.SOCK_DGRAM
+    )
+    return info[0][4][:2]  # type: ignore[return-value]
+
+
 def _hello_packet(local_ip_address: str, port: int) -> bytearray:
     packet = bytearray(0x30)
     packet[0x08:0x14] = Datetime.pack(Datetime.now())
@@ -117,13 +154,14 @@ async def scan(
     local_ip_address: str | None = None,
     discover_ip_address: str = DEFAULT_BCAST_ADDR,
     discover_ip_port: int = DEFAULT_PORT,
-) -> AsyncIterator[HelloResponse]:
+) -> AsyncGenerator[HelloResponse]:
     """Broadcast a hello message and yield responses as they arrive.
 
     The hello is repeated every ``DEFAULT_RETRY_INTVL`` seconds until
     ``timeout`` elapses. Each device is yielded once.
     """
     local_addr = (local_ip_address, 0) if local_ip_address else None
+    target = await _resolve(discover_ip_address, discover_ip_port)
     transport, protocol = await _open_endpoint(local_addr=local_addr, broadcast=True)
     try:
         if local_ip_address:
@@ -138,7 +176,7 @@ async def scan(
         discovered: set[tuple[tuple[str, int], bytes, int]] = set()
 
         while (loop.time() - start) < timeout:
-            transport.sendto(packet, (discover_ip_address, discover_ip_port))
+            transport.sendto(packet, target)
             deadline = min(DEFAULT_RETRY_INTVL, timeout - (loop.time() - start))
             slot_end = loop.time() + deadline
             while True:
@@ -149,7 +187,11 @@ async def scan(
                     resp, host = await asyncio.wait_for(protocol.queue.get(), remaining)
                 except TimeoutError:
                     break
-                if len(resp) < 0x80:
+                if resp is None:
+                    return  # The transport was closed under us.
+                if isinstance(resp, Exception):
+                    raise resp
+                if host is None or len(resp) < 0x80:
                     continue
                 entry = _parse_hello(resp, host)
                 key = (entry[1], entry[2], entry[0])
@@ -161,6 +203,19 @@ async def scan(
         transport.close()
 
 
+async def send_setup_packet(
+    payload: bytes, ip_address: str, port: int = DEFAULT_PORT
+) -> None:
+    """Broadcast one Wi-Fi provisioning packet to a device in AP mode."""
+    target = await _resolve(ip_address, port)
+    transport, protocol = await _open_endpoint(broadcast=True)
+    try:
+        transport.sendto(payload, target)
+        protocol.raise_if_error()
+    finally:
+        transport.close()
+
+
 async def ping(ip_address: str, port: int = DEFAULT_PORT) -> None:
     """Send a ping packet to an address.
 
@@ -168,11 +223,13 @@ async def ping(ip_address: str, port: int = DEFAULT_PORT) -> None:
     Useful to prevent reboots when the cloud cannot be reached.
     It must be sent every 2 minutes in such cases.
     """
-    transport, _ = await _open_endpoint(broadcast=True)
+    target = await _resolve(ip_address, port)
+    transport, protocol = await _open_endpoint(broadcast=True)
     try:
         packet = bytearray(0x30)
         packet[0x26] = 1
-        transport.sendto(packet, (ip_address, port))
+        transport.sendto(packet, target)
+        protocol.raise_if_error()
     finally:
         transport.close()
 
@@ -213,12 +270,13 @@ class Device:
         self.aes = None
         self.update_aes(bytes.fromhex(self.__INIT_KEY))
 
-        self._lock: asyncio.Lock | None = None
+        self._lock = asyncio.Lock()
         self._transport: asyncio.DatagramTransport | None = None
         self._protocol: _Protocol | None = None
         self._endpoint_addr: tuple[str, int] | None = None
         self._recent: collections.deque[int] = collections.deque(maxlen=_RECENT_MAX)
-        self._reauth_lock: asyncio.Lock | None = None
+        self._reauth_lock = asyncio.Lock()
+        self._closes = 0  # Bumped by aclose(); guards an open racing a close.
         self._auth_generation = 0
 
     def __repr__(self) -> str:
@@ -277,9 +335,6 @@ class Device:
         packet[0x2D] = 0x01
         packet[0x30:0x36] = b"Test 1"
 
-        if self._lock is None:
-            self._lock = asyncio.Lock()
-            self._reauth_lock = asyncio.Lock()
         async with self._lock:
             self.id = 0
             self.update_aes(bytes.fromhex(self.__INIT_KEY))
@@ -292,7 +347,7 @@ class Device:
         _LOGGER.debug("%s: authenticated, session id %d", self.host[0], self.id)
         return True
 
-    async def hello(self, local_ip_address=None) -> bool:
+    async def hello(self, local_ip_address: str | None = None) -> bool:
         """Send a hello message to the device.
 
         Device information is checked before updating name and lock status.
@@ -385,6 +440,7 @@ class Device:
         A request in flight fails at once with ``ConnectionClosedError``
         rather than waiting out its timeout.
         """
+        self._closes += 1
         transport, protocol = self._transport, self._protocol
         self._transport = None
         self._protocol = None
@@ -395,13 +451,37 @@ class Device:
         if protocol is not None:
             protocol.queue.put_nowait(_CLOSED)  # type: ignore[arg-type]
 
+    def _drop_endpoint(self) -> None:
+        """Throw the endpoint away after a failure; the next call reopens it.
+
+        A connected datagram socket can go bad for good (the interface
+        bounced, the host's address changed), and the original library
+        never noticed because it opened a socket per call. Dropping the
+        endpoint whenever a request fails restores that self-healing.
+        """
+        transport = self._transport
+        self._transport = None
+        self._protocol = None
+        self._endpoint_addr = None
+        if transport is not None:
+            transport.close()
+            _LOGGER.debug("%s: endpoint dropped after a failure", self.host[0])
+
     async def _endpoint(self) -> tuple[asyncio.DatagramTransport, _Protocol]:
         if self._transport is not None and self._endpoint_addr != self.host:
             # The caller changed host; the connected socket points at the
             # old address, so drop it.
             await self.aclose()
         if self._transport is None or self._transport.is_closing():
-            self._transport, self._protocol = await _open_endpoint(remote_addr=self.host)
+            closes = self._closes
+            transport, protocol = await _open_endpoint(remote_addr=self.host)
+            if self._closes != closes:
+                # aclose() ran while the socket was being opened.
+                transport.close()
+                raise e.EndpointClosedError(
+                    -4013, "Endpoint closed", "The device endpoint was closed"
+                )
+            self._transport, self._protocol = transport, protocol
             self._endpoint_addr = self.host
             _LOGGER.debug("%s: endpoint opened", self.host[0])
         return self._transport, self._protocol  # type: ignore[return-value]
@@ -490,6 +570,19 @@ 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])
+                    continue
+                if isinstance(resp, Exception):
+                    # A send failure (no route, address gone) or a fatal
+                    # transport error: fail now and throw the socket away.
+                    _LOGGER.debug("%s: socket error: %s", self.host[0], resp)
+                    self._drop_endpoint()
+                    raise resp
                 resp = self._validate(resp)
                 reply_count = int.from_bytes(resp[0x28:0x2A], "little")
                 if reply_count == count or reply_count not in self._recent:
@@ -501,33 +594,40 @@ class Device:
                 )
             if loop.time() - start >= timeout:
                 _LOGGER.debug("%s: no reply within %ss", self.host[0], timeout)
+                self._drop_endpoint()
                 raise e.NetworkTimeoutError(
                     -4000,
                     "Network timeout",
                     f"No response received within {timeout}s",
                 ) from None
 
-    async def send_packet(self, packet_type: int, payload: bytes) -> bytes:
+    async def send_packet(self, packet_type: int, payload: bytes | bytearray) -> bytes:
         """Send a packet to the device and return the raw response frame.
 
         If the device answers that the session key is no longer valid, the
         session is re-authenticated once and the request is sent again.
         Concurrent callers that hit the same expired key share one
-        re-authentication and each retry once.
+        re-authentication and each retry once. If that re-authentication
+        fails (for example the device has been locked in the app), the
+        original reply is returned unchanged, so the caller sees the same
+        error the original library raised and can run its own recovery.
         """
-        if self._lock is None:
-            self._lock = asyncio.Lock()
-            self._reauth_lock = asyncio.Lock()
-        generation = self._auth_generation
         async with self._lock:
+            generation = self._auth_generation
             resp = await self._exchange(self._frame(packet_type, bytes(payload)))
 
         code = int.from_bytes(resp[0x22:0x24], "little", signed=True)
         if code in _REAUTH_CODES:
             _LOGGER.debug("%s: device answered %d, re-authenticating", self.host[0], code)
-            async with self._reauth_lock:  # type: ignore[union-attr]
+            async with self._reauth_lock:
                 if self._auth_generation == generation:
-                    await self.auth()
+                    try:
+                        await self.auth()
+                    except e.BroadlinkException as err:
+                        _LOGGER.debug(
+                            "%s: re-authentication failed: %s", self.host[0], err
+                        )
+                        return resp
             async with self._lock:
                 resp = await self._exchange(self._frame(packet_type, bytes(payload)))
         return resp

{python_broadlink-1.0.2 → python_broadlink-1.0.4}/broadlink/exceptions.py

@@ -168,6 +168,6 @@ def exception(err_code: int) -> BroadlinkException:
 
 def check_error(error: bytes) -> None:
     """Raise exception if an error occurred."""
-    error_code = struct.unpack("h", error)[0]
+    error_code = struct.unpack("<h", error)[0]
     if error_code:
         raise exception(error_code)