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

python_broadlink-1.0.2/CHANGELOG.md

@@ -0,0 +1,200 @@
+# Changelog
+
+All notable changes to this project are recorded here. The format follows
+Keep a Changelog; versions follow Semantic Versioning.
+
+## 1.0.2 - 2026-09-05
+
+Fixes from a second, adversarial review of 1.0.1 and a re-test of the
+first review's findings. No change to the wire format or the public API.
+
+### Fixed
+
+- 1.0.1's reply matching dropped a late reply to a request that had
+  timed out, but not the second reply to a request that was resent after a
+  silent second and then answered twice. That duplicate carries the counter
+  of a request that succeeded, and it could still be taken as the answer
+  to the next request. The library now remembers every recently used
+  counter and drops any reply carrying one other than the current
+  request's. A reply whose counter the device has not used recently is
+  still accepted, for firmware that may not echo it.
+- `auth()` reset the session id and key before taking the request lock, so
+  a request already queued behind the lock could be framed with device id
+  0 and the initial key. The reset, the exchange and the install of the
+  new key now happen as one unit under the lock.
+- 1.0.1 let a new capture window close one that a consumer had abandoned,
+  using "is the generator running right now" as the test. That cannot
+  tell an abandoned window from one whose consumer is awaiting something
+  between signals, which the README's own example does. A new window now
+  gives asyncio's finalizer one turn to close a genuinely dropped
+  generator and then refuses if the old window is still alive, rather
+  than taking it. A refused attempt no longer displaces the live window.
+- A packet the device returned that cannot be decoded (a declared length
+  running into a truncated escape) no longer ends the capture window; it
+  is logged and the window re-arms.
+- `aclose()` during a request now raises `EndpointClosedError`, a subclass
+  of `ConnectionClosedError` with code -4013 in the error table, so a
+  caller that closed the device on purpose can tell that apart from the
+  device's own "logged out" answer.
+- `hello()` closes the discovery generator it breaks out of instead of
+  leaving the socket to the finalizer; `asyncio.TimeoutError` is spelled
+  `TimeoutError`; an unused future on the protocol object is gone.
+
+### Added
+
+- Debug logging on the `broadlink.device` and `broadlink.remote` loggers:
+  endpoint open and close, resends, dropped late replies, timeouts,
+  re-authentication, capture arm and re-arm, captured packets.
+- README: a "Closing" section on the persistent socket, a "Timing" section
+  with the bench measurement of the tick fix (5.4 percent short before,
+  0.6 percent short after, on an RM4 Pro against an independent
+  receiver), a note that Python 3.13 is a support decision, and the short
+  list of return-value differences from 0.19.0.
+
+### Changed
+
+- The code is formatted with `ruff format` and CI checks it.
+
+## 1.0.1 - 2026-09-05
+
+Fixes from an independent review of 1.0.0, most of them in the transport.
+None changes the wire format or the public API.
+
+### Fixed
+
+- A reply to a request that had already timed out could be delivered as the
+  reply to the next request on the same device, because the persistent
+  endpoint (new in 1.0.0) is not thrown away between calls the way the old
+  per-call socket was. Replies are now matched to their request by the
+  packet counter the device echoes at offset 0x28; a reply carrying the
+  counter of a request that already timed out is discarded, and a reply
+  whose counter matches nothing the device sent is still accepted, so
+  firmware that does not echo the counter is unaffected. Confirmed on an
+  RM4 Pro, which echoes it.
+- `capture()` treated only `StorageError` (-5) as "nothing captured yet".
+  Some firmware answers `ReadError` (-10); both are now treated as "nothing
+  yet", matching what the original CLI and Home Assistant do while polling.
+  The CLI's `--learn` and `--rflearn` inherit the fix.
+- Abandoning a capture generator without closing it (for example `break`
+  out of `async for` to take one code) no longer blocks the next
+  `capture()` on the same device: opening a new window closes an abandoned
+  one. Opening a window while another is actively being iterated still
+  raises `CaptureInProgressError`. A new read-only `Device.capture_active`
+  property reports whether a window is open.
+- Re-authentication is now shared between concurrent callers: when several
+  requests hit an expired session key at once, the library authenticates
+  once and every caller retries, instead of one caller re-authenticating
+  and the others surfacing the raw error. The logged-out code (-2) now
+  triggers re-authentication as well, matching Home Assistant's own retry.
+- Changing `device.host` after the endpoint is open now reopens it against
+  the new address instead of continuing to talk to the old one.
+- `aclose()` while a request is in flight fails that request at once with
+  `ConnectionClosedError` instead of waiting out the timeout.
+
+### Documentation
+
+- The README explains that `broadlink` and `python-broadlink` install the
+  same package name and cannot coexist, and how to recover if both were
+  installed.
+- The changelog no longer describes the carried-over device commits as
+  "intact" (they were squash-merged with `Co-authored-by` credit) and no
+  longer overstates what the oracle records.
+
+## 1.0.0 - 2026-09-05
+
+This is the first release of `python-broadlink`, a maintained fork of
+`mjg59/python-broadlink` (PyPI `broadlink`, last released as 0.19.0). The
+history below starts at that fork point.
+
+### Changed
+
+- **The library is asynchronous.** Every method that talks to a device is
+  now a coroutine: `await device.auth()`, `await device.send_data(...)`,
+  `await device.check_sensors()`, and so on. Discovery is
+  `await broadlink.discover(...)`, `broadlink.hello(...)` and `setup(...)`
+  are coroutines, and `xdiscover(...)` is an async generator. The packet
+  helpers (`pulses_to_data`, `data_to_pulses`), CRC and datetime helpers
+  stay synchronous. There is no synchronous compatibility layer: a call
+  without `await` returns a coroutine and does nothing.
+- Each device keeps one UDP endpoint for its lifetime (the previous
+  version opened a socket per call) and serializes requests on it with an
+  `asyncio.Lock`. The old code declared a lock but never acquired it.
+  `async with device:` or `await device.aclose()` releases the endpoint;
+  it reopens on the next call.
+- When a device reports that the session key has expired, the library
+  re-authenticates once and repeats the request. Callers no longer need
+  their own re-auth loop.
+- Retry and timeout behaviour is unchanged: a request is repeated every
+  second until `timeout` elapses, then `NetworkTimeoutError` is raised.
+- `dooya.set_percentage_and_wait` sleeps with `asyncio.sleep`.
+- The CLI tools run their body under `asyncio.run`. `broadlink_cli
+  --learn` and `--rflearn` use `capture()` / `capture_rf()`, so a learning
+  session no longer goes deaf when the device times out partway through;
+  `--window` sets how long to listen, `--keep` prints every code heard, and
+  `--send --durations --repeat N` sets the repeat count. The CLI README's
+  `--rfscanlearn` was a typo for `--rflearn` (mjg59/python-broadlink#803,
+  #830).
+- `pulses_to_data` returns `bytes` (it returned a `bytearray`, against its
+  own annotation).
+- The device's request lock is now a private `_lock` that is actually
+  acquired; the unused public `Device.lock` attribute is gone.
+- Packaging moved to `pyproject.toml`; `setup.py` and the stale
+  `requirements.txt` pin are gone. The distribution name is now
+  `python-broadlink`; the import name stays `broadlink`. Python 3.13 or
+  newer is required.
+- Continuous integration now runs `ruff` and `pytest` on Python 3.13 and
+  3.14, and builds the sdist and wheel on every pull request. Releases are
+  published to PyPI from version tags using trusted publishing.
+
+### Fixed
+
+- The IR tick constant used by `pulses_to_data` and `data_to_pulses` is now
+  `TICK = 8192 / 269` (about 30.45 us), matching the device's 32768 Hz
+  timebase as documented in `protocol.md`. The previous value, 32.84, was
+  the inverse ratio applied the wrong way round and compressed IR codes
+  built from true microsecond timings by about 7 percent. Codes learned and
+  replayed through the same device were unaffected. Verified on an RM4 Pro
+  against an independent receiver in both directions.
+  (mjg59/python-broadlink#839, #841)
+- `pulses_to_data` rounds each duration to the nearest tick instead of
+  truncating, which removes up to one tick of systematic shortening per
+  pulse.
+
+### Added
+
+- `capture()` and `capture_rf()`, async generators that own the arm, poll,
+  timeout and re-arm loop of a learning session and yield each signal as a
+  `CapturedSignal` (device packet, decoded pulses at the correct tick,
+  kind, repeat count, and for RF the carrier frequency). They re-arm on a
+  timer, because the device leaves learning mode silently, and after any
+  `send_data`, because a transmission ends the session; both intervals and
+  the poll cadence were set from a bench on an RM4 Pro. Only one window can
+  be open per device. `capture_rf()` (Pro models only) takes the carrier
+  frequency directly and falls back to the on-device sweep when it is not
+  given.
+- Packet helpers: `pulses_to_data` takes `kind` and `repeat`, `parse_packet`
+  is its inverse, and `SignalKind` names the IR, 433 MHz and 315 MHz bands.
+  A device's returned RF packet does not always use the canonical type byte
+  (an RM4 Pro answers a 433 MHz capture with 0xB1, not 0xB2), so the kind is
+  read by band and a capture is tagged from what it armed rather than the
+  byte.
+- Devices, carried over from pull requests against the original repository
+  with their authors credited (the changes were squash-merged with
+  `Co-authored-by` trailers naming each author): RM Max 0xAF8B (#838, Alexey Masolov);
+  RM5 plus 0x5224 with a new `rm5plus` class (#831, Anil Daoud); RM mini 3
+  OEM 0xA544 (#823, Bartłomiej Nogaś); RM mini 3 CMCC 0x27C8 (#802,
+  shuxin); LB26 R1 0xA517 (#812, techitapart); SP mini 3-AL 0x7D15 (#805,
+  bbcbbk); LEDVANCE SMART+ WIFI CEILING TW 24W 0x6498 (#799, Felipe Martins
+  Diel).
+- Devices reported in issues against the original repository, added by
+  model name to the existing class for that family and not yet confirmed on
+  hardware: MP1-1K3S2U 0x4EDA (#816) and SP4 0xA57A (#758). Please open an
+  issue if either does not behave.
+- `cryptography` 43 or newer is required, the first release with wheels for
+  Python 3.13 (supersedes mjg59/python-broadlink#749).
+- A test suite. The `tests/oracle` package records, for every public method
+  of every device class, the request each one hands to the transport (its
+  packet type and plaintext payload) and the result it decodes from a canned
+  response, so that a later reimplementation can be checked against the
+  original method by method; the framing, encryption and checksum layer is
+  covered separately by `tests/test_transport.py`.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.0
+Version: 1.0.2
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -47,20 +47,25 @@ A Python module and CLI for controlling Broadlink devices locally.
 
 ## Version 1.0 is asynchronous
 
-Every call that reaches a device is a coroutine and must be awaited. This
-is the whole change from the original library's API; method names,
-arguments and return values are the same.
+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).
 
 ```python
 import asyncio
 import broadlink
 
+
 async def main():
     devices = await broadlink.discover(timeout=5)
     device = devices[0]
     await device.auth()
     print(await device.check_sensors())
 
+
 asyncio.run(main())
 ```
 
@@ -83,17 +88,48 @@ The following devices are supported:
 - **Thermostats**: Hysen HY02B05H
 - **Hubs**: S3
 
+## Timing
+
+The original library converted microseconds to the device's timing units
+with the constant 32.84, which is the right ratio applied the wrong way
+round, and it shortened every IR code built from microsecond timings by
+about 7 percent. Codes learned from a remote and replayed through the same
+device were never affected, which is why it went unnoticed for years.
+Version 1.0 uses 8192/269 (about 30.45 us per unit), the value implied by
+`protocol.md`, and rounds to the nearest unit instead of truncating.
+
+Measured on an RM4 Pro against an independent receiver, the same NEC frame
+packed with the old constant arrived 5.4 percent short of its intended
+length; packed with the corrected constant it arrived 0.6 percent short,
+twice, thirteen hours apart, within 22 us of itself. Packets learned by
+the device and replayed by name are unchanged. Anything that stores
+microsecond timings produced by the old `data_to_pulses` (which reported
+them about 7.8 percent long) and re-encodes them with the new
+`pulses_to_data` will lengthen by that amount; store the device packet
+instead, as `CapturedSignal.packet` does.
+
 ## Installation
 
+Python 3.13 or newer. That is a support decision rather than a technical
+one: the code runs on 3.11, but the versions tested in CI are 3.13 and
+3.14 and those are the ones Home Assistant ships.
+
 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
 
@@ -118,7 +154,7 @@ In order to control the device, you need to connect it to your local network. If
   - Manually connect to the WiFi SSID named BroadlinkProv.
 2. Connect the device to your local network with the setup function.
 ```python3
-await broadlink.setup('myssid', 'mynetworkpass', 3)
+await broadlink.setup("myssid", "mynetworkpass", 3)
 ```
 
 Security mode options are (0 = none, 1 = WEP, 2 = WPA1, 3 = WPA2, 4 = WPA1/2)
@@ -127,7 +163,7 @@ Security mode options are (0 = none, 1 = WEP, 2 = WPA1, 3 = WPA2, 4 = WPA1/2)
 
 You may need to specify a broadcast address if setup is not working.
 ```python3
-await broadlink.setup('myssid', 'mynetworkpass', 3, ip_address='192.168.0.255')
+await broadlink.setup("myssid", "mynetworkpass", 3, ip_address="192.168.0.255")
 ```
 
 ### Discovery
@@ -143,17 +179,17 @@ You may need to specify `local_ip_address` or `discover_ip_address` if discovery
 
 Using the IP address of your local machine:
 ```python3
-devices = await broadlink.discover(local_ip_address='192.168.0.100')
+devices = await broadlink.discover(local_ip_address="192.168.0.100")
 ```
 
 Using the broadcast address of your subnet:
 ```python3
-devices = await broadlink.discover(discover_ip_address='192.168.0.255')
+devices = await broadlink.discover(discover_ip_address="192.168.0.255")
 ```
 
 If the device is locked, it may not be discoverable with broadcast. In such cases, you can use the unicast version `broadlink.hello()` for direct discovery:
 ```python3
-device = await broadlink.hello('192.168.0.16')
+device = await broadlink.hello("192.168.0.16")
 ```
 
 If you are a perfomance freak, use `broadlink.xdiscover()` to create devices instantly:
@@ -168,6 +204,27 @@ After discovering the device, call the `auth()` method to obtain the authenticat
 await device.auth()
 ```
 
+### Closing
+
+Each device keeps one UDP socket open for its lifetime (the original
+library opened a new one for every call). Close it when you are done with
+the device, either with the context manager or explicitly:
+
+```python3
+async with device:
+    await device.auth()
+    print(await device.check_sensors())
+
+# or
+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.
+
 The next steps depend on the type of device you want to control.
 
 ## Universal remotes
@@ -199,7 +256,7 @@ await device.sweep_frequency()
 ```python3
 ok, frequency = await device.check_frequency()
 if ok:
-    print(f'Frequency found: {frequency} MHz')
+    print(f"Frequency found: {frequency} MHz")
 ```
 4. Enter learning mode:
 ```python3
@@ -241,10 +298,13 @@ By default the window closes after the first signal. Pass
 `window=0` runs until the generator is closed), re-arming after each signal
 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.
+device at a time: opening a second one raises `CaptureInProgressError`
+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.
 
 `CapturedSignal` carries the device's own `packet` bytes (ready for
-`send_data`), the decoded `pulses` in microseconds at the correct tick, the
+`send_data`), the decoded `pulses` in microseconds at the corrected tick, the
 `kind` (`SignalKind.IR`, `RF_433` or `RF_315`), the `repeat` count, and for
 RF the `frequency_mhz` the packet itself does not record.
 

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

@@ -16,20 +16,25 @@ A Python module and CLI for controlling Broadlink devices locally.
 
 ## Version 1.0 is asynchronous
 
-Every call that reaches a device is a coroutine and must be awaited. This
-is the whole change from the original library's API; method names,
-arguments and return values are the same.
+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).
 
 ```python
 import asyncio
 import broadlink
 
+
 async def main():
     devices = await broadlink.discover(timeout=5)
     device = devices[0]
     await device.auth()
     print(await device.check_sensors())
 
+
 asyncio.run(main())
 ```
 
@@ -52,17 +57,48 @@ The following devices are supported:
 - **Thermostats**: Hysen HY02B05H
 - **Hubs**: S3
 
+## Timing
+
+The original library converted microseconds to the device's timing units
+with the constant 32.84, which is the right ratio applied the wrong way
+round, and it shortened every IR code built from microsecond timings by
+about 7 percent. Codes learned from a remote and replayed through the same
+device were never affected, which is why it went unnoticed for years.
+Version 1.0 uses 8192/269 (about 30.45 us per unit), the value implied by
+`protocol.md`, and rounds to the nearest unit instead of truncating.
+
+Measured on an RM4 Pro against an independent receiver, the same NEC frame
+packed with the old constant arrived 5.4 percent short of its intended
+length; packed with the corrected constant it arrived 0.6 percent short,
+twice, thirteen hours apart, within 22 us of itself. Packets learned by
+the device and replayed by name are unchanged. Anything that stores
+microsecond timings produced by the old `data_to_pulses` (which reported
+them about 7.8 percent long) and re-encodes them with the new
+`pulses_to_data` will lengthen by that amount; store the device packet
+instead, as `CapturedSignal.packet` does.
+
 ## Installation
 
+Python 3.13 or newer. That is a support decision rather than a technical
+one: the code runs on 3.11, but the versions tested in CI are 3.13 and
+3.14 and those are the ones Home Assistant ships.
+
 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
 
@@ -87,7 +123,7 @@ In order to control the device, you need to connect it to your local network. If
   - Manually connect to the WiFi SSID named BroadlinkProv.
 2. Connect the device to your local network with the setup function.
 ```python3
-await broadlink.setup('myssid', 'mynetworkpass', 3)
+await broadlink.setup("myssid", "mynetworkpass", 3)
 ```
 
 Security mode options are (0 = none, 1 = WEP, 2 = WPA1, 3 = WPA2, 4 = WPA1/2)
@@ -96,7 +132,7 @@ Security mode options are (0 = none, 1 = WEP, 2 = WPA1, 3 = WPA2, 4 = WPA1/2)
 
 You may need to specify a broadcast address if setup is not working.
 ```python3
-await broadlink.setup('myssid', 'mynetworkpass', 3, ip_address='192.168.0.255')
+await broadlink.setup("myssid", "mynetworkpass", 3, ip_address="192.168.0.255")
 ```
 
 ### Discovery
@@ -112,17 +148,17 @@ You may need to specify `local_ip_address` or `discover_ip_address` if discovery
 
 Using the IP address of your local machine:
 ```python3
-devices = await broadlink.discover(local_ip_address='192.168.0.100')
+devices = await broadlink.discover(local_ip_address="192.168.0.100")
 ```
 
 Using the broadcast address of your subnet:
 ```python3
-devices = await broadlink.discover(discover_ip_address='192.168.0.255')
+devices = await broadlink.discover(discover_ip_address="192.168.0.255")
 ```
 
 If the device is locked, it may not be discoverable with broadcast. In such cases, you can use the unicast version `broadlink.hello()` for direct discovery:
 ```python3
-device = await broadlink.hello('192.168.0.16')
+device = await broadlink.hello("192.168.0.16")
 ```
 
 If you are a perfomance freak, use `broadlink.xdiscover()` to create devices instantly:
@@ -137,6 +173,27 @@ After discovering the device, call the `auth()` method to obtain the authenticat
 await device.auth()
 ```
 
+### Closing
+
+Each device keeps one UDP socket open for its lifetime (the original
+library opened a new one for every call). Close it when you are done with
+the device, either with the context manager or explicitly:
+
+```python3
+async with device:
+    await device.auth()
+    print(await device.check_sensors())
+
+# or
+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.
+
 The next steps depend on the type of device you want to control.
 
 ## Universal remotes
@@ -168,7 +225,7 @@ await device.sweep_frequency()
 ```python3
 ok, frequency = await device.check_frequency()
 if ok:
-    print(f'Frequency found: {frequency} MHz')
+    print(f"Frequency found: {frequency} MHz")
 ```
 4. Enter learning mode:
 ```python3
@@ -210,10 +267,13 @@ By default the window closes after the first signal. Pass
 `window=0` runs until the generator is closed), re-arming after each signal
 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.
+device at a time: opening a second one raises `CaptureInProgressError`
+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.
 
 `CapturedSignal` carries the device's own `packet` bytes (ready for
-`send_data`), the decoded `pulses` in microseconds at the correct tick, the
+`send_data`), the decoded `pulses` in microseconds at the corrected tick, the
 `kind` (`SignalKind.IR`, `RF_433` or `RF_315`), the `repeat` count, and for
 RF the `frequency_mhz` the packet itself does not record.
 

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

@@ -1,7 +1,9 @@
 #!/usr/bin/env python3
 """The python-broadlink library."""
+
+import contextlib
 from collections.abc import AsyncIterator
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from . import exceptions as e
 from .alarm import S1C
@@ -223,8 +225,8 @@ SUPPORTED_TYPES = {
 
 def gendevice(
     dev_type: int,
-    host: Tuple[str, int],
-    mac: Union[bytes, str],
+    host: tuple[str, int],
+    mac: bytes | str,
     name: str = "",
     is_locked: bool = False,
 ) -> Device:
@@ -258,12 +260,15 @@ async def hello(
 
     Useful if the device is locked.
     """
-    async for device in xdiscover(
-        timeout=timeout,
-        discover_ip_address=ip_address,
-        discover_ip_port=port,
-    ):
-        return device
+    async with contextlib.aclosing(
+        xdiscover(
+            timeout=timeout,
+            discover_ip_address=ip_address,
+            discover_ip_port=port,
+        )
+    ) as devices:
+        async for device in devices:
+            return device
     raise e.NetworkTimeoutError(
         -4000,
         "Network timeout",
@@ -273,10 +278,10 @@ async def hello(
 
 async def discover(
     timeout: float = DEFAULT_TIMEOUT,
-    local_ip_address: Optional[str] = None,
+    local_ip_address: str | None = None,
     discover_ip_address: str = DEFAULT_BCAST_ADDR,
     discover_ip_port: int = DEFAULT_PORT,
-) -> List[Device]:
+) -> list[Device]:
     """Discover devices connected to the local network."""
     return [
         device
@@ -288,7 +293,7 @@ async def discover(
 
 async def xdiscover(
     timeout: float = DEFAULT_TIMEOUT,
-    local_ip_address: Optional[str] = None,
+    local_ip_address: str | None = None,
     discover_ip_address: str = DEFAULT_BCAST_ADDR,
     discover_ip_port: int = DEFAULT_PORT,
 ) -> AsyncIterator[Device]:

{python_broadlink-1.0.0 → python_broadlink-1.0.2}/broadlink/alarm.py

@@ -1,4 +1,5 @@
 """Support for alarm kits."""
+
 from . import exceptions as e
 from .device import Device