python-broadlink 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

broadlink/__init__.py

@@ -1,7 +1,7 @@
 """The python-broadlink library."""
 
 import contextlib
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator
 
 from . import exceptions as e
 from .alarm import S1C
@@ -116,6 +116,9 @@ SUPPORTED_TYPES = {
         0x27A6: ("RM plus", "Broadlink"),
         0x27A9: ("RM pro+", "Broadlink"),
         0x27C3: ("RM pro+", "Broadlink"),
+        # The RM Max answers the RM pro framing; the RM4 framing (length
+        # prefix) gets "device is locked" from it. Tested on hardware in
+        # upstream #838, whose text says rm4pro but whose diff says rmpro.
         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(
@@ -294,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.

broadlink/device.py

@@ -12,10 +12,11 @@ from __future__ import annotations
 import asyncio
 import collections
 import contextlib
+import errno
 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,12 +49,36 @@ _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``."""
+
+
+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."""
+    """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: asyncio.BaseTransport) -> None:
@@ -65,18 +90,30 @@ class _Protocol(asyncio.DatagramProtocol):
         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:
-        """Nothing to do; a waiting request is told through the queue."""
+        """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,
@@ -95,6 +132,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())
@@ -119,13 +171,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:
@@ -140,7 +193,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:
@@ -151,7 +204,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])
@@ -167,9 +224,11 @@ 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."""
-    transport, _ = await _open_endpoint(broadcast=True)
+    target = await _resolve(ip_address, port)
+    transport, protocol = await _open_endpoint(broadcast=True)
     try:
-        transport.sendto(payload, (ip_address, port))
+        transport.sendto(payload, target)
+        protocol.raise_if_error()
     finally:
         transport.close()
 
@@ -181,11 +240,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()
 
@@ -407,6 +468,22 @@ 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
@@ -510,6 +587,22 @@ class Device:
                     raise e.EndpointClosedError(
                         -4013, "Endpoint closed", "The device endpoint was closed"
                     )
+                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
+                    # 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:
@@ -521,6 +614,7 @@ 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",

broadlink/remote.py

@@ -1,12 +1,12 @@
 """Support for universal remotes."""
 
 import asyncio
+import contextlib
 import enum
 import logging
 import struct
 import time
-import weakref
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Self
 
@@ -18,9 +18,10 @@ _LOGGER = logging.getLogger(__name__)
 TICK = 8192 / 269
 """Duration of one Broadlink timing unit in microseconds (about 30.45 us).
 
-The RM firmware counts pulses on a 32768 Hz clock (protocol.md: us * 269 / 8192).
-Earlier releases used 32.84, the inverse of the right ratio applied the wrong
-way round, which compressed externally sourced IR codes by about 7 percent
+The value comes from protocol.md, whose conversion "us * 269 / 8192 works
+very well" was measured against real firmware; 8192/269 is its inverse.
+Earlier releases used 32.84, the right ratio applied the wrong way round,
+which compressed externally sourced IR codes by about 7 percent
 (mjg59/python-broadlink#839). Codes learned and replayed through the same
 device were unaffected because both directions shared the constant.
 """
@@ -176,7 +177,7 @@ class CapturedSignal:
     repeat: int = 0
     frequency_mhz: float | None = None
     type_byte: int | None = None
-    captured_at: float = field(default_factory=time.time, repr=False)
+    captured_at: float = field(default_factory=time.time, repr=False, compare=False)
 
     @classmethod
     def from_packet(
@@ -220,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."""
@@ -300,7 +289,7 @@ class rmmini(Device):
         stop_after_first: bool = True,
         poll_interval: float = DEFAULT_POLL_INTERVAL,
         rearm_interval: float = DEFAULT_REARM_INTERVAL,
-    ) -> AsyncIterator[CapturedSignal]:
+    ) -> AsyncGenerator[CapturedSignal]:
         """Open an infrared capture window and yield what the device hears.
 
         The device is put into learning mode and polled every
@@ -318,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,
@@ -332,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,
@@ -347,18 +332,43 @@ class rmmini(Device):
         kind: SignalKind,
         frequency_mhz: float | None,
         *,
-        claim: list | None = None,
-    ) -> AsyncIterator[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: bool,
+    ) -> AsyncGenerator[CapturedSignal]:
+        # ``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
@@ -457,7 +467,7 @@ class rmpro(rmmini):
         stop_after_first: bool = True,
         poll_interval: float = DEFAULT_POLL_INTERVAL,
         rearm_interval: float = DEFAULT_REARM_INTERVAL,
-    ) -> AsyncIterator[CapturedSignal]:
+    ) -> AsyncGenerator[CapturedSignal]:
         """Open a radio frequency capture window and yield what the device hears.
 
         With ``frequency`` (in MHz, for example 433.92) the device goes
@@ -474,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,
@@ -494,13 +495,26 @@ class rmpro(rmmini):
         stop_after_first: bool,
         poll_interval: float,
         rearm_interval: float,
-        *,
-        claim: list,
-    ) -> AsyncIterator[CapturedSignal]:
+    ) -> 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:
+            async for signal in self._capture_rf_body(
+                window, frequency, stop_after_first, poll_interval, rearm_interval
+            ):
+                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
 
@@ -525,13 +539,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

broadlink/sensor.py

@@ -1,6 +1,6 @@
 """Support for sensors."""
 
-from collections.abc import Sequence
+import struct
 
 from . import exceptions as e
 from .device import Device
@@ -48,35 +48,35 @@ class a2(Device):
 
     TYPE = "A2"
 
-    async def _send(self, operation: int, data: Sequence = b""):
-        """Send a command to the device."""
-        packet = bytearray(12)
-        packet[0x02] = 0xA5
-        packet[0x03] = 0xA5
-        packet[0x04] = 0x5A
-        packet[0x05] = 0x5A
-        packet[0x08] = operation
-        packet[0x09] = 0x0B
-
-        if data:
-            data_len = len(data)
-            packet[0x0A] = data_len & 0xFF
-            packet[0x0B] = data_len >> 8
-            packet += bytes(2)
-            packet.extend(data)
-
-        checksum = sum(packet, 0xBEAF) & 0xFFFF
-        packet[0x06] = checksum & 0xFF
-        packet[0x07] = checksum >> 8
-
-        packet_len = len(packet) - 2
-        packet[0x00] = packet_len & 0xFF
-        packet[0x01] = packet_len >> 8
+    async def _send(self, operation: int, data: bytes = b"") -> bytes:
+        """Send a command to the device.
+
+        The frame is the one the SP4 and LB1 families use: a two-byte
+        length, the A5A5 5A5A marker, a checksum, the operation, 0x0B and
+        a four-byte data length. The 0.19.0 code wrote a two-byte data
+        length and a length field two short, and real A2 units answered
+        every request with error -5 (mjg59/python-broadlink#826).
+        """
+        packet = bytearray(14)
+        struct.pack_into(
+            "<HHHHBBI",
+            packet,
+            0,
+            12 + len(data),
+            0xA5A5,
+            0x5A5A,
+            0,
+            operation,
+            0x0B,
+            len(data),
+        )
+        packet.extend(data)
+        checksum = sum(packet[0x02:], 0xBEAF) & 0xFFFF
+        packet[0x06:0x08] = checksum.to_bytes(2, "little")
 
         resp = await self.send_packet(0x6A, packet)
         e.check_error(resp[0x22:0x24])
-        payload = self.decrypt(resp[0x38:])
-        return payload
+        return self.decrypt(resp[0x38:])
 
     async def check_sensors_raw(self) -> dict:
         """Return the state of the sensors in raw format."""

{python_broadlink-1.0.3.dist-info → python_broadlink-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.3
+Version: 1.0.5
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -193,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():
@@ -231,11 +236,21 @@ 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`. 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.
 
@@ -311,7 +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. 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.3.dist-info → python_broadlink-1.0.5.dist-info}/RECORD

@@ -1,19 +1,19 @@
-broadlink/__init__.py,sha256=wXL3gDxcmE563q4Kjsx9vzWn8Jgopj9Ls7kl4sC0qNQ,10821
+broadlink/__init__.py,sha256=OJCaOs_IOgLqdaVe4bH3ALQEs-IVFV3lGFd5da7o2w4,11138
 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=dP2RbnxZve_m9bJsis51KfDwPNxxJuGapPltYuWF50M,21507
+broadlink/device.py,sha256=Y3uzlrZ0CaAIhpNO7ap4DvKlLpqNQVKp9kXjcKxTqRI,25786
 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=1TO3xo_rhp9_Zt8yFRL3Im_IUH9Nbvt9pwyn9gstk18,22418
-broadlink/sensor.py,sha256=dhetprwgv45gkyvHgS2jJrYVuSQ2z-IXJynykgXo_2k,2701
+broadlink/remote.py,sha256=sXDvBneN5dppAyMi3-d1ysVPu6-tF1ugHMzpBEMr-_E,22382
+broadlink/sensor.py,sha256=Pa4fJnG28wPFIf7HSN4JQ3cIOfAdTCu5I0spnBG12Qg,2791
 broadlink/switch.py,sha256=0VurdoGf3CTrYBSQU4ahVSLC_FYHqIRWr3dLkBwIatI,14985
-python_broadlink-1.0.3.dist-info/licenses/LICENSE,sha256=h0N_LWq34pY0W-Ky3ayO6Re5ejG0XvutPlW-GL8eG5I,1111
-python_broadlink-1.0.3.dist-info/METADATA,sha256=YQblobXPiUvcd2rGgxclX3M_JuFMp77kB4d6uSAuJNs,15046
-python_broadlink-1.0.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_broadlink-1.0.3.dist-info/top_level.txt,sha256=_Qx7d8oNTOLeDkAN-HHDoq1FlRNlsiaMZlyMWgHXAVc,10
-python_broadlink-1.0.3.dist-info/RECORD,,
+python_broadlink-1.0.5.dist-info/licenses/LICENSE,sha256=h0N_LWq34pY0W-Ky3ayO6Re5ejG0XvutPlW-GL8eG5I,1111
+python_broadlink-1.0.5.dist-info/METADATA,sha256=h7AZlQhasZUDjRbtIEB_JmUAsRPIkf7gsUXl7fb3QvA,15948
+python_broadlink-1.0.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_broadlink-1.0.5.dist-info/top_level.txt,sha256=_Qx7d8oNTOLeDkAN-HHDoq1FlRNlsiaMZlyMWgHXAVc,10
+python_broadlink-1.0.5.dist-info/RECORD,,