python-broadlink 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

broadlink/device.py

@@ -10,6 +10,7 @@ speaks unprompted, so each device keeps a single datagram endpoint and an
 from __future__ import annotations
 
 import asyncio
+import collections
 import random
 import socket
 from collections.abc import AsyncIterator
@@ -30,8 +31,17 @@ from .protocol import Datetime
 HelloResponse = Tuple[int, Tuple[str, int], bytes, str, bool]
 
 # Device error codes that mean the session key is no longer accepted and a
-# fresh auth() will fix it. -7: control key expired; -4012: control id error.
-_REAUTH_CODES = {-7, -4012}
+# fresh auth() will fix it. -2: logged out; -7: control key expired;
+# -4012: control id error.
+_REAUTH_CODES = {-2, -7, -4012}
+
+# How many timed-out request counters to remember, so that a reply to one
+# of them arriving late is recognised and dropped instead of being taken as
+# the answer to a later request.
+_ABANDONED_MAX = 32
+
+_CLOSED = (None, None)
+"""Sentinel put on the receive queue when the endpoint is closed."""
 
 
 class _Protocol(asyncio.DatagramProtocol):
@@ -203,7 +213,10 @@ class Device:
         self._lock: Optional[asyncio.Lock] = None
         self._transport: Optional[asyncio.DatagramTransport] = None
         self._protocol: Optional[_Protocol] = None
-        self._reauth_ok = True
+        self._endpoint_addr: Optional[Tuple[str, int]] = None
+        self._abandoned: collections.deque[int] = collections.deque(maxlen=_ABANDONED_MAX)
+        self._reauth_lock: Optional[asyncio.Lock] = None
+        self._auth_generation = 0
 
     def __repr__(self) -> str:
         """Return a formal representation of the device."""
@@ -275,6 +288,7 @@ class Device:
 
         self.id = int.from_bytes(payload[:0x4], "little")
         self.update_aes(payload[0x04:0x14])
+        self._auth_generation += 1
         return True
 
     async def hello(self, local_ip_address=None) -> bool:
@@ -363,17 +377,30 @@ class Device:
     # -------------------------------------------------------- transport
 
     async def aclose(self) -> None:
-        """Close the device's endpoint. It is reopened on the next call."""
-        if self._transport is not None:
-            self._transport.close()
-            self._transport = None
-            self._protocol = None
+        """Close the device's endpoint. It is reopened on the next call.
+
+        A request in flight fails at once with ``ConnectionClosedError``
+        rather than waiting out its timeout.
+        """
+        transport, protocol = self._transport, self._protocol
+        self._transport = None
+        self._protocol = None
+        self._endpoint_addr = None
+        if transport is not None:
+            transport.close()
+        if protocol is not None:
+            protocol.queue.put_nowait(_CLOSED)  # type: ignore[arg-type]
 
     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
             )
+            self._endpoint_addr = self.host
         return self._transport, self._protocol  # type: ignore[return-value]
 
     def _frame(self, packet_type: int, payload: bytes) -> bytes:
@@ -419,28 +446,53 @@ class Device:
         return resp
 
     async def _exchange(self, packet: bytes) -> bytes:
-        """Send one frame and wait for one reply, resending on silence."""
+        """Send one frame and wait for its reply, resending on silence.
+
+        Replies carry the request's packet counter (offset 0x28), so a reply
+        is matched to the request by counter. A reply whose counter belongs
+        to a request that already timed out is dropped; one with a counter
+        this device has never sent is accepted, for firmware that may not
+        echo it.
+        """
         transport, protocol = await self._endpoint()
         protocol.drain()
         loop = asyncio.get_running_loop()
         start = loop.time()
         timeout = self.timeout
+        count = int.from_bytes(packet[0x28:0x2A], "little")
 
         while True:
             transport.sendto(packet)
-            time_left = timeout - (loop.time() - start)
-            wait = min(DEFAULT_RETRY_INTVL, time_left)
-            try:
-                resp, _ = await asyncio.wait_for(protocol.queue.get(), max(wait, 0))
-            except asyncio.TimeoutError:
-                if (loop.time() - start) >= timeout:
-                    raise e.NetworkTimeoutError(
-                        -4000,
-                        "Network timeout",
-                        f"No response received within {timeout}s",
-                    ) from None
-                continue
-            return self._validate(resp)
+            resend_at = loop.time() + DEFAULT_RETRY_INTVL
+            while True:
+                now = loop.time()
+                if now - start >= timeout:
+                    break
+                wait = min(resend_at, start + timeout) - now
+                try:
+                    resp, _ = await asyncio.wait_for(protocol.queue.get(), max(wait, 0))
+                except asyncio.TimeoutError:
+                    if loop.time() - start >= timeout:
+                        break
+                    if loop.time() >= resend_at:
+                        break  # Resend.
+                    continue
+                if resp is None:
+                    raise e.ConnectionClosedError(
+                        -4013, "Connection closed", "The device endpoint was closed"
+                    )
+                resp = self._validate(resp)
+                reply_count = int.from_bytes(resp[0x28:0x2A], "little")
+                if reply_count == count or reply_count not in self._abandoned:
+                    return resp
+                # A late answer to a request we gave up on: keep waiting.
+            if loop.time() - start >= timeout:
+                self._abandoned.append(count)
+                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, *, _reauth: bool = True
@@ -449,22 +501,24 @@ class Device:
 
         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.
         """
         if self._lock is None:
             self._lock = asyncio.Lock()
+            self._reauth_lock = asyncio.Lock()
+        generation = self._auth_generation
         async with self._lock:
             resp = await self._exchange(self._frame(packet_type, bytes(payload)))
 
-        if _reauth and self._reauth_ok:
+        if _reauth:
             code = int.from_bytes(resp[0x22:0x24], "little", signed=True)
             if code in _REAUTH_CODES:
-                self._reauth_ok = False
-                try:
-                    await self.auth()
-                    async with self._lock:
-                        resp = await self._exchange(
-                            self._frame(packet_type, bytes(payload))
-                        )
-                finally:
-                    self._reauth_ok = True
+                async with self._reauth_lock:  # type: ignore[union-attr]
+                    if self._auth_generation == generation:
+                        await self.auth()
+                async with self._lock:
+                    resp = await self._exchange(
+                        self._frame(packet_type, bytes(payload))
+                    )
         return resp

broadlink/remote.py

@@ -4,6 +4,7 @@ import asyncio
 import enum
 import struct
 import time
+import weakref
 from dataclasses import dataclass, field
 from typing import AsyncIterator, Awaitable, Callable, List, Optional, Tuple
 
@@ -214,7 +215,40 @@ 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
-        self._capture_open = False
+        # Weak reference to the async generator of the current capture
+        # window, if any. See _claim_window.
+        self._window: Optional[weakref.ReferenceType] = None
+
+    @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
+
+    def _check_window(self) -> Optional[weakref.ReferenceType]:
+        """Refuse a new window while another is being iterated; return the
+        reference to a previous window that the new one should close."""
+        old = self._window() if self._window is not None else None
+        if old is None or old.ag_frame is None:
+            return None
+        if old.ag_running:
+            raise e.CaptureInProgressError("A capture window is already open")
+        return self._window
+
+    async def _claim_window(self, prev: Optional[weakref.ReferenceType]) -> None:
+        """Close a previous window whose consumer walked away from it.
+
+        A window whose consumer is still iterating it is live and a new one
+        is refused at call time (``_check_window``). One the consumer broke
+        out of without closing the generator is not live; it is closed here
+        so that it cannot block the device forever.
+        """
+        old = prev() if prev is not None else None
+        if old is None or old.ag_frame is None:
+            return
+        if old.ag_running:
+            raise e.CaptureInProgressError("A capture window is already open")
+        await old.aclose()
 
     async def _send(self, command: int, data: bytes = b"") -> bytes:
         """Send a packet to the device."""
@@ -266,10 +300,13 @@ class rmmini(Device):
         and after every ``send_data`` on the same device. Closing the
         generator sends nothing further; the device times out by itself.
         Use ``contextlib.aclosing`` (or iterate to the end) so the window is
-        released promptly. Only one capture window can be open per device;
-        a second raises ``CaptureInProgressError``.
+        released promptly. Only one capture window can be open per device:
+        opening one while another is being iterated raises
+        ``CaptureInProgressError``, and opening one after breaking out of
+        another without closing it closes the old one.
         """
-        return self._capture_loop(
+        prev = self._check_window()
+        gen = self._capture_loop(
             self.enter_learning,
             window,
             stop_after_first,
@@ -277,7 +314,10 @@ class rmmini(Device):
             rearm_interval,
             SignalKind.IR,
             None,
+            prev=prev,
         )
+        self._window = weakref.ref(gen)
+        return gen
 
     async def _capture_loop(
         self,
@@ -288,58 +328,60 @@ class rmmini(Device):
         rearm_interval: float,
         kind: SignalKind,
         frequency_mhz: Optional[float],
+        *,
+        prev: Optional[weakref.ReferenceType] = None,
+        claim: bool = True,
     ) -> AsyncIterator[CapturedSignal]:
         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 self._capture_open:
-            raise e.CaptureInProgressError("A capture window is already open")
+        if claim:
+            await self._claim_window(prev)
 
-        self._capture_open = True
-        try:
-            loop = asyncio.get_running_loop()
-            deadline = loop.time() + window if window else None
-            timeouts = 0
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + window if window else None
+        timeouts = 0
+
+        await arm()
+        armed_at = loop.time()
+        generation = self._tx_generation
 
-            await arm()
-            armed_at = loop.time()
-            generation = self._tx_generation
+        while True:
+            now = loop.time()
+            if deadline is not None and now >= deadline:
+                return
+            delay = poll_interval
+            if deadline is not None:
+                delay = min(delay, deadline - now)
+            await asyncio.sleep(delay)
 
-            while True:
-                now = loop.time()
-                if deadline is not None and now >= deadline:
+            try:
+                data = await self.check_data()
+            except (e.StorageError, e.ReadError):
+                # "Nothing yet": -5 on the RM4 Pro, -10 on some older
+                # firmware (upstream's CLI and Home Assistant tolerate
+                # both).
+                data = b""
+            except e.NetworkTimeoutError:
+                timeouts += 1
+                if timeouts >= 3:
+                    raise
+                generation = -1  # Re-arm; the device's state is unknown.
+                continue
+            timeouts = 0
+
+            if data:
+                yield CapturedSignal.from_packet(data, frequency_mhz, kind=kind)
+                if stop_after_first:
                     return
-                delay = poll_interval
-                if deadline is not None:
-                    delay = min(delay, deadline - now)
-                await asyncio.sleep(delay)
-
-                try:
-                    data = await self.check_data()
-                except e.StorageError:
-                    data = b""  # The device's answer for "nothing yet".
-                except e.NetworkTimeoutError:
-                    timeouts += 1
-                    if timeouts >= 3:
-                        raise
-                    generation = -1  # Re-arm; the device's state is unknown.
-                    continue
-                timeouts = 0
-
-                if data:
-                    yield CapturedSignal.from_packet(data, frequency_mhz, kind=kind)
-                    if stop_after_first:
-                        return
-                    generation = -1  # One code per session: re-arm.
-
-                now = loop.time()
-                if generation != self._tx_generation or now - armed_at >= rearm_interval:
-                    await arm()
-                    armed_at = loop.time()
-                    generation = self._tx_generation
-        finally:
-            self._capture_open = False
+                generation = -1  # One code per session: re-arm.
+
+            now = loop.time()
+            if generation != self._tx_generation or now - armed_at >= rearm_interval:
+                await arm()
+                armed_at = loop.time()
+                generation = self._tx_generation
 
 
 class rmpro(rmmini):
@@ -369,7 +411,7 @@ class rmpro(rmmini):
         """Cancel sweep frequency."""
         await self._send(0x1E)
 
-    async def capture_rf(
+    def capture_rf(
         self,
         window: float = 30.0,
         *,
@@ -389,24 +431,38 @@ class rmpro(rmmini):
 
         The window, polling, re-arm and stop-after-first semantics are those
         of ``capture``; the sweep counts against the same ``window``. A
-        ``send_data`` during the sweep restarts it. Each ``CapturedSignal``
-        carries the carrier in ``frequency_mhz``, which the packet itself
-        does not record.
+        ``send_data`` during the sweep restarts it. Closing the generator
+        during a sweep sends nothing; the device ends the sweep on its own.
+        Each ``CapturedSignal`` carries the carrier in ``frequency_mhz``,
+        which the packet itself does not record.
         """
-        if self._capture_open:
-            raise e.CaptureInProgressError("A capture window is already open")
+        prev = self._check_window()
+        gen = self._capture_rf_loop(
+            window, frequency, stop_after_first, poll_interval, rearm_interval,
+            prev=prev,
+        )
+        self._window = weakref.ref(gen)
+        return gen
+
+    async def _capture_rf_loop(
+        self,
+        window: float,
+        frequency: Optional[float],
+        stop_after_first: bool,
+        poll_interval: float,
+        rearm_interval: float,
+        *,
+        prev: Optional[weakref.ReferenceType],
+    ) -> AsyncIterator[CapturedSignal]:
         if window < 0 or poll_interval <= 0:
             raise ValueError("window must be 0 or positive, poll_interval positive")
+        await self._claim_window(prev)
 
         loop = asyncio.get_running_loop()
         deadline = loop.time() + window if window else None
 
         if frequency is None:
-            self._capture_open = True
-            try:
-                frequency = await self._sweep(deadline, poll_interval)
-            finally:
-                self._capture_open = False
+            frequency = await self._sweep(deadline, poll_interval)
             if frequency is None:
                 return
             if deadline is not None:
@@ -418,10 +474,15 @@ class rmpro(rmmini):
             await self.find_rf_packet(frequency)
 
         kind = SignalKind.RF_315 if frequency < 400 else SignalKind.RF_433
-        async for signal in self._capture_loop(
-            arm, window, stop_after_first, poll_interval, rearm_interval, kind, frequency
-        ):
-            yield signal
+        inner = self._capture_loop(
+            arm, window, stop_after_first, poll_interval, rearm_interval, kind, frequency,
+            claim=False,
+        )
+        try:
+            async for signal in inner:
+                yield signal
+        finally:
+            await inner.aclose()
 
     async def _sweep(
         self, deadline: Optional[float], poll_interval: float

{python_broadlink-1.0.0.dist-info → python_broadlink-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.0
+Version: 1.0.1
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -91,9 +91,16 @@ Use pip3 to install the latest version of this module.
 pip3 install python-broadlink
 ```
 
-If the original `broadlink` distribution is also installed in the same
-environment, remove it first (`pip3 uninstall broadlink`); both provide the
-`broadlink` package.
+Both this distribution and the original `broadlink` install a package named
+`broadlink`, so only one can be present in an environment at a time. Pip
+does not warn about this: installing one on top of the other appears to
+succeed, and whichever was installed last is the one that `import broadlink`
+finds. If both were installed, uninstall both (`pip3 uninstall broadlink
+python-broadlink`) and reinstall this one, since `pip3 uninstall broadlink`
+alone removes the shared files and leaves `python-broadlink` registered but
+unimportable. This matters most where another package pins `broadlink`:
+installing it into the same environment silently replaces this async
+library with the original synchronous one.
 
 ## Basic functions
 

{python_broadlink-1.0.0.dist-info → python_broadlink-1.0.1.dist-info}/RECORD

@@ -3,17 +3,17 @@ broadlink/alarm.py,sha256=ZsPKG4xibM9mxuuiWJcv_XPOOwFogGMfuP-3qOvyuA0,1259
 broadlink/climate.py,sha256=YJUi6oVrvY941R5AqToADObZbjuQd7NZ7E2u0UbVrMM,15826
 broadlink/const.py,sha256=MDzkcoaWN_4zXPTiG2DnYZgr6w97zX7tsnDfImYgA-Q,119
 broadlink/cover.py,sha256=bnUmQYUucxOogmYjmk57vwDsIvMjDIL_WKvMb-IdjJc,5438
-broadlink/device.py,sha256=aBu9zC5O_SDK-lv1L-Qy-_C74Cwzwy_TUMbIjFj5Dfk,16721
+broadlink/device.py,sha256=_3Ia-SXjeywcCi99-81zPhpotOIj0r-IENOr0sM1fLU,19248
 broadlink/exceptions.py,sha256=0uooFfEd34id60fddcsXvU7uQ_4lFt07iDYDE5NkCSA,4756
 broadlink/helpers.py,sha256=Kpm7GUSXmwhNMJGFWfVNJ_1idcO1D-k5rgzHbO8vDlM,1296
 broadlink/hub.py,sha256=unQ45HIzIUmixqXrb7RvuWO5y7wvGAHFEPfR8OVWsjA,2929
 broadlink/light.py,sha256=2t7Jumm4DHP81RzeLFUQQDhXK5VcvgmH3osrkufCaIs,7782
 broadlink/protocol.py,sha256=9pNT6HrsCzHyeqpzhxKOkR58GjHhfVz8QdyefceI4tE,1847
-broadlink/remote.py,sha256=19tw-H58tDJHJipCyxee9hUUFErG2ao6_NRXiMg5ofw,18057
+broadlink/remote.py,sha256=pqs7NWE8m21U9V3F44KA-Gdk4Ai5oj5nLLj81WS9_xo,20405
 broadlink/sensor.py,sha256=K76lAF-addjaq3-l6pl-buaqZelRd62sDE21cEz-lnI,2691
 broadlink/switch.py,sha256=WzCi-UbWSlIEytGc9E0-oAje2Z8E1453eUYmFq_hjf8,15060
-python_broadlink-1.0.0.dist-info/licenses/LICENSE,sha256=h0N_LWq34pY0W-Ky3ayO6Re5ejG0XvutPlW-GL8eG5I,1111
-python_broadlink-1.0.0.dist-info/METADATA,sha256=hGLTSEsgJJQIsoam0j7AjMFvLymcl-dDXX5PDVTL9ZU,11369
-python_broadlink-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_broadlink-1.0.0.dist-info/top_level.txt,sha256=_Qx7d8oNTOLeDkAN-HHDoq1FlRNlsiaMZlyMWgHXAVc,10
-python_broadlink-1.0.0.dist-info/RECORD,,
+python_broadlink-1.0.1.dist-info/licenses/LICENSE,sha256=h0N_LWq34pY0W-Ky3ayO6Re5ejG0XvutPlW-GL8eG5I,1111
+python_broadlink-1.0.1.dist-info/METADATA,sha256=1KVEvHEbXlFG_dZYBLf6cMl2RihqDyo841FzjC_xog8,11908
+python_broadlink-1.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_broadlink-1.0.1.dist-info/top_level.txt,sha256=_Qx7d8oNTOLeDkAN-HHDoq1FlRNlsiaMZlyMWgHXAVc,10
+python_broadlink-1.0.1.dist-info/RECORD,,