python-broadlink 1.0.1__tar.gz → 1.0.3__tar.gz

{python_broadlink-1.0.1 → python_broadlink-1.0.3}/CHANGELOG.md

@@ -3,6 +3,103 @@
 All notable changes to this project are recorded here. The format follows
 Keep a Changelog; versions follow Semantic Versioning.
 
+## 1.0.3 - 2026-09-06
+
+Fixes from a third review, this one of 1.0.2. No change to the wire
+format. One small API change: `pulses` on a captured signal is a tuple.
+
+### Fixed
+
+- When the device answered that the session key had expired and the
+  re-authentication then failed (for example because the device had been
+  locked in the app), the call raised `AuthenticationError` from the
+  re-authentication instead of the error the device gave the request. The
+  original library never re-authenticated, so a program written against
+  it, Home Assistant's integration included, handles the request's own
+  error and never expected the other one. The failed re-authentication is
+  now logged and the request's original reply is returned, so the caller
+  sees the same `AuthorizationError` or `ConnectionClosedError` it always
+  did.
+- The authentication generation was read before the request lock was
+  taken rather than under it, so a request queued behind an `auth()`
+  could observe a stale generation and skip a re-authentication it needed.
+- `aclose()` racing an endpoint that was still being opened could leave
+  the new socket open and unreferenced. The open now notices the close
+  and fails with `EndpointClosedError`.
+- After a new capture window gives the finalizer its turn, it re-checks
+  that no other window claimed the device in the meantime.
+- `CapturedSignal` and `ParsedPacket` are frozen dataclasses, but they
+  held a list, so they could not be hashed or put in a set. `pulses` is
+  now a `tuple[int, ...]`.
+- `check_error` unpacks the error code as little-endian explicitly
+  (`"<h"`), matching the rest of the code, instead of native order.
+- The CLI closes the device it opens instead of leaving that to
+  `asyncio.run`, which warned under `python -X dev`.
+- The locks are created in `__init__` rather than lazily in two places.
+
+### Changed
+
+- `send_packet` accepts a `bytearray` payload as well as `bytes`.
+- `setup()` sends its provisioning packet through a new
+  `send_setup_packet()` helper in `broadlink.device` instead of reaching
+  into a private function.
+- README: the re-authentication contract and its worst case (one call can
+  wait out up to three timeouts), the A2 sensor and the Hysen HY02/HY03
+  in the device list, and the hello response's `mac` being `bytes` in the
+  list of differences from 0.19.0.
+
+## 1.0.2 - 2026-09-05
+
+Fixes from a second, adversarial review of 1.0.1 and a re-test of the
+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.

{python_broadlink-1.0.1/python_broadlink.egg-info → python_broadlink-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-broadlink
-Version: 1.0.1
+Version: 1.0.3
 Summary: Python API for controlling Broadlink devices
 Author: DAB-LABS
 Author-email: Matthew Garrett <mjg59@srcf.ucam.org>
@@ -47,20 +47,26 @@ 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, `timeout`
+parameters typed as floats, and the `mac` in a hello response typed as
+`bytes`).
 
 ```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())
 ```
 
@@ -76,15 +82,39 @@ The following devices are supported:
 - **Switches**: MCB1, SC1, SCB1E, SCB2
 - **Outlets**: BG 800, BG 900
 - **Power strips**: MP1-1K3S2U, MP1-1K4S, MP2
-- **Environment sensors**: A1
+- **Environment sensors**: A1, A2
 - **Alarm kits**: S1C, S2KIT
 - **Light bulbs**: LB1, LB26 R1, LB27 R1, SB800TD, LEDVANCE SMART+ WIFI CEILING TW 24W
 - **Curtain motors**: Dooya DT360E-45/20
-- **Thermostats**: Hysen HY02B05H
+- **Thermostats**: Hysen HY02/HY03
 - **Hubs**: S3
 
+## Timing
+
+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.
 
 ```
@@ -125,7 +155,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)
@@ -134,7 +164,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
@@ -150,17 +180,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:
@@ -175,6 +205,38 @@ After discovering the device, call the `auth()` method to obtain the authenticat
 await device.auth()
 ```
 
+The session key expires on the device after a while. When a request comes
+back with an expired-key answer, the library authenticates again and
+repeats the request once, so a long-running program does not need to
+handle that itself. If the second authentication fails, for example
+because the device was locked in the app in the meantime, the call raises
+the error the device gave the first time, the same `AuthorizationError`
+or `ConnectionClosedError` the original library raised, and it is up to
+the caller to decide what to do. In the worst case one call can wait out
+three timeouts (the request, the authentication, and the repeat), each
+bounded by `device.timeout`.
+
+### Closing
+
+Each device keeps one UDP socket open for its lifetime (the original
+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
@@ -206,7 +268,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
@@ -248,10 +310,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.1 → python_broadlink-1.0.3}/README.md

@@ -16,20 +16,26 @@ 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, `timeout`
+parameters typed as floats, and the `mac` in a hello response typed as
+`bytes`).
 
 ```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())
 ```
 
@@ -45,15 +51,39 @@ The following devices are supported:
 - **Switches**: MCB1, SC1, SCB1E, SCB2
 - **Outlets**: BG 800, BG 900
 - **Power strips**: MP1-1K3S2U, MP1-1K4S, MP2
-- **Environment sensors**: A1
+- **Environment sensors**: A1, A2
 - **Alarm kits**: S1C, S2KIT
 - **Light bulbs**: LB1, LB26 R1, LB27 R1, SB800TD, LEDVANCE SMART+ WIFI CEILING TW 24W
 - **Curtain motors**: Dooya DT360E-45/20
-- **Thermostats**: Hysen HY02B05H
+- **Thermostats**: Hysen HY02/HY03
 - **Hubs**: S3
 
+## Timing
+
+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.
 
 ```
@@ -94,7 +124,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)
@@ -103,7 +133,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
@@ -119,17 +149,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:
@@ -144,6 +174,38 @@ After discovering the device, call the `auth()` method to obtain the authenticat
 await device.auth()
 ```
 
+The session key expires on the device after a while. When a request comes
+back with an expired-key answer, the library authenticates again and
+repeats the request once, so a long-running program does not need to
+handle that itself. If the second authentication fails, for example
+because the device was locked in the app in the meantime, the call raises
+the error the device gave the first time, the same `AuthorizationError`
+or `ConnectionClosedError` the original library raised, and it is up to
+the caller to decide what to do. In the worst case one call can wait out
+three timeouts (the request, the authentication, and the repeat), each
+bounded by `device.timeout`.
+
+### Closing
+
+Each device keeps one UDP socket open for its lifetime (the original
+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
@@ -175,7 +237,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
@@ -217,10 +279,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.1 → python_broadlink-1.0.3}/broadlink/__init__.py

@@ -1,14 +1,14 @@
-#!/usr/bin/env python3
 """The python-broadlink library."""
+
+import contextlib
 from collections.abc import AsyncIterator
-from typing import List, Optional, Tuple, Union
 
 from . import exceptions as e
 from .alarm import S1C
 from .climate import hvac, hysen
 from .const import DEFAULT_BCAST_ADDR, DEFAULT_PORT, DEFAULT_TIMEOUT
 from .cover import dooya, dooya2, wser
-from .device import Device, _open_endpoint, ping, scan
+from .device import Device, ping, scan, send_setup_packet
 from .hub import s3
 from .light import lb1, lb2
 from .remote import rm, rm4, rm4mini, rm4pro, rm5plus, rmmini, rmminib, rmpro
@@ -223,8 +223,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 +258,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 +276,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 +291,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]:
@@ -335,8 +338,4 @@ async def setup(
     payload[0x20] = checksum & 0xFF  # Checksum 1 position
     payload[0x21] = checksum >> 8  # Checksum 2 position
 
-    transport, _ = await _open_endpoint(broadcast=True)
-    try:
-        transport.sendto(payload, (ip_address, DEFAULT_PORT))
-    finally:
-        transport.close()
+    await send_setup_packet(bytes(payload), ip_address)

{python_broadlink-1.0.1 → python_broadlink-1.0.3}/broadlink/alarm.py

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

{python_broadlink-1.0.1 → python_broadlink-1.0.3}/broadlink/climate.py

@@ -1,7 +1,8 @@
 """Support for climate control."""
+
 import enum
 import struct
-from typing import List, Sequence
+from collections.abc import Sequence
 
 from . import exceptions as e
 from .device import Device
@@ -33,7 +34,7 @@ class hysen(Device):
         payload = self.decrypt(response[0x38:])
 
         p_len = int.from_bytes(payload[:0x02], "little")
-        nom_crc = int.from_bytes(payload[p_len:p_len+2], "little")
+        nom_crc = int.from_bytes(payload[p_len : p_len + 2], "little")
         real_crc = CRC16.calculate(payload[0x02:p_len])
 
         if nom_crc != real_crc:
@@ -83,9 +84,7 @@ class hysen(Device):
         data["dif"] = payload[10]
         data["svh"] = payload[11]
         data["svl"] = payload[12]
-        data["room_temp_adj"] = (
-            int.from_bytes(payload[13:15], "big", signed=True) / 10.0
-        )
+        data["room_temp_adj"] = int.from_bytes(payload[13:15], "big", signed=True) / 10.0
         data["fre"] = payload[15]
         data["poweron"] = payload[16]
         data["unknown"] = payload[17]
@@ -127,9 +126,7 @@ class hysen(Device):
     # E.g. loop_mode = 0 ("12345,67") means Saturday and Sunday (weekend schedule)
     # loop_mode = 2 ("1234567") means every day, including Saturday and Sunday (weekday schedule)
     # The sensor command is currently experimental
-    async def set_mode(
-        self, auto_mode: int, loop_mode: int, sensor: int = 0
-    ) -> None:
+    async def set_mode(self, auto_mode: int, loop_mode: int, sensor: int = 0) -> None:
         """Set the mode of the device."""
         mode_byte = ((loop_mode + 1) << 4) + auto_mode
         await self.send_request([0x01, 0x06, 0x00, 0x02, mode_byte, sensor])
@@ -210,19 +207,7 @@ class hysen(Device):
     async def set_time(self, hour: int, minute: int, second: int, day: int) -> None:
         """Set the time."""
         await self.send_request(
-            [
-                0x01,
-                0x10,
-                0x00,
-                0x08,
-                0x00,
-                0x02,
-                0x04,
-                hour,
-                minute,
-                second,
-                day
-            ]
+            [0x01, 0x10, 0x00, 0x08, 0x00, 0x02, 0x04, hour, minute, second, day]
         )
 
     # Set timer schedule
@@ -231,7 +216,7 @@ class hysen(Device):
     # {'start_hour':17, 'start_minute':30, 'temp': 22 }
     # Each one specifies the thermostat temp that will become effective at start_hour:start_minute
     # weekend is similar but only has 2 (e.g. switch on in morning and off in afternoon)
-    async def set_schedule(self, weekday: List[dict], weekend: List[dict]) -> None:
+    async def set_schedule(self, weekday: list[dict], weekend: list[dict]) -> None:
         """Set timer schedule."""
         request = [0x01, 0x10, 0x00, 0x0A, 0x00, 0x0C, 0x18]
 
@@ -317,9 +302,7 @@ class hvac(Device):
         """Encode data for transport."""
         packet = bytearray(10)
         p_len = 10 + len(data)
-        struct.pack_into(
-            "<HHHHH", packet, 0, p_len, 0x00BB, 0x8006, 0, len(data)
-        )
+        struct.pack_into("<HHHHH", packet, 0, p_len, 0x00BB, 0x8006, 0, len(data))
         packet += data
         crc = CRC16.calculate(packet[0x02:], polynomial=0x9BE4)
         packet += crc.to_bytes(2, "little")
@@ -330,7 +313,7 @@ class hvac(Device):
         # payload[0x2:0x8] == bytes([0xbb, 0x00, 0x07, 0x00, 0x00, 0x00])
         payload = self.decrypt(response[0x38:])
         p_len = int.from_bytes(payload[:0x02], "little")
-        nom_crc = int.from_bytes(payload[p_len:p_len+2], "little")
+        nom_crc = int.from_bytes(payload[p_len : p_len + 2], "little")
         real_crc = CRC16.calculate(payload[0x02:p_len], polynomial=0x9BE4)
 
         if nom_crc != real_crc:
@@ -341,7 +324,7 @@ class hvac(Device):
             )
 
         d_len = int.from_bytes(payload[0x08:0x0A], "little")
-        return payload[0x0A:0x0A+d_len]
+        return payload[0x0A : 0x0A + d_len]
 
     async def _send(self, command: int, data: bytes = b"") -> bytes:
         """Send a command to the unit."""

{python_broadlink-1.0.1 → python_broadlink-1.0.3}/broadlink/const.py

@@ -1,4 +1,5 @@
 """Constants."""
+
 DEFAULT_BCAST_ADDR = "255.255.255.255"
 DEFAULT_PORT = 80
 DEFAULT_RETRY_INTVL = 1

{python_broadlink-1.0.1 → python_broadlink-1.0.3}/broadlink/cover.py

@@ -1,6 +1,7 @@
 """Support for covers."""
+
 import asyncio
-from typing import Sequence
+from collections.abc import Sequence
 
 from . import exceptions as e
 from .device import Device