python-broadlink 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

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(

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

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.dist-info → python_broadlink-1.0.6.dist-info}/METADATA

@@ -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.dist-info → python_broadlink-1.0.6.dist-info}/RECORD

@@ -1,19 +1,19 @@
-broadlink/__init__.py,sha256=CYuVoYuKsXTd69yx7X9lIYr3DEPFlUL88bE4rcZMqb4,10890
+broadlink/__init__.py,sha256=zlf8v225DdjvT_yDELRPAsQcAC4e5rrdlP0nyTBL7ms,11145
 broadlink/alarm.py,sha256=tmeNI-AaPna5nbgoTqz_AGmuQVItGTmt7zyNiRLsSlQ,1260
 broadlink/climate.py,sha256=fciXwQ0P2_kOaJiXAprfXuDyhLdHU--mE6pCYkVWdF8,15592
 broadlink/const.py,sha256=Y0XSxYr1k27FKqHWBirJsUB0HGxQ1riIZ9rfVEJaIL4,120
 broadlink/cover.py,sha256=-wW1BPmf5Z8oeLuqDVEpUyU-PgId5CJ91M3g3RjgVAU,5448
-broadlink/device.py,sha256=-aAZfV_CSWqIeFowewQo5Dn3vvp2YclZ4E19qOc_hVQ,24883
+broadlink/device.py,sha256=Noy3Uj_7XfFDhgH92C1GM4smdRK_2-VR-aP6f3PjKAY,26378
 broadlink/exceptions.py,sha256=S8xOGdzyFGd6ULXUlblDwE-MADoJIR49itEo0j_fZNU,5226
 broadlink/helpers.py,sha256=Zbw7lNRMB08P5FPAtKMJLExBjts_Gq64tJbR7-JwxX8,1294
 broadlink/hub.py,sha256=e78lDKcdtDNqSOZkQRqLMPMFR0PgT2g3E7VgULCq-QM,2869
 broadlink/light.py,sha256=fWCoaf6JmDfcc7ggRmehss9D3cp66evUDlcB50Iu2LI,7660
 broadlink/protocol.py,sha256=eRCm0fGdApVp5ko_fOP79lazQklda8N6x30ty6P0TiA,1848
-broadlink/remote.py,sha256=3UjIvyps9BmCCPemGiWCm5BgCsNpT2TjD3dKznQ93JI,22487
+broadlink/remote.py,sha256=t0CBCrzbUuA1wX066odpPuQSnkppcPnJSBV6oDYDeMo,22462
 broadlink/sensor.py,sha256=Pa4fJnG28wPFIf7HSN4JQ3cIOfAdTCu5I0spnBG12Qg,2791
 broadlink/switch.py,sha256=0VurdoGf3CTrYBSQU4ahVSLC_FYHqIRWr3dLkBwIatI,14985
-python_broadlink-1.0.4.dist-info/licenses/LICENSE,sha256=h0N_LWq34pY0W-Ky3ayO6Re5ejG0XvutPlW-GL8eG5I,1111
-python_broadlink-1.0.4.dist-info/METADATA,sha256=5uZ80FW7Vd0OzTsttoPeI78P0oXJHbLWXRkh92Rb-vE,15819
-python_broadlink-1.0.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_broadlink-1.0.4.dist-info/top_level.txt,sha256=_Qx7d8oNTOLeDkAN-HHDoq1FlRNlsiaMZlyMWgHXAVc,10
-python_broadlink-1.0.4.dist-info/RECORD,,
+python_broadlink-1.0.6.dist-info/licenses/LICENSE,sha256=h0N_LWq34pY0W-Ky3ayO6Re5ejG0XvutPlW-GL8eG5I,1111
+python_broadlink-1.0.6.dist-info/METADATA,sha256=B8Qv617UFdGn6gustQIUxRdlY2b1qSwHYHHnuiN5rSA,15948
+python_broadlink-1.0.6.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_broadlink-1.0.6.dist-info/top_level.txt,sha256=_Qx7d8oNTOLeDkAN-HHDoq1FlRNlsiaMZlyMWgHXAVc,10
+python_broadlink-1.0.6.dist-info/RECORD,,