lifx-async 5.0.0__tar.gz → 5.1.0__tar.gz

{lifx_async-5.0.0 → lifx_async-5.1.0}/.github/workflows/ci.yml

@@ -35,7 +35,7 @@ jobs:
     - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6
 
     - name: Set up Python
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       with:
         python-version: ${{ env.PYTHON_VERSION }}
 
@@ -62,6 +62,47 @@ jobs:
         uv pip install "bandit[toml]"
         uv run bandit -c pyproject.toml -r src/
 
+  # Verify auto-generated files are up-to-date
+  generated-files:
+    name: Verify Generated Files
+    needs: quality
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6
+
+    - name: Set up Python
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+      with:
+        python-version: ${{ env.PYTHON_VERSION }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
+      with:
+        version: ${{ env.UV_VERSION }}
+        python-version: ${{ env.PYTHON_VERSION }}
+
+    - name: Install dependencies
+      run: uv sync --frozen
+
+    - name: Regenerate protocol files
+      run: uv run python -m lifx.protocol.generator
+
+    - name: Regenerate product registry
+      run: uv run python -m lifx.products.generator
+
+    - name: Format and lint generated files
+      run: |
+        uv run ruff format src/lifx/protocol/packets.py src/lifx/protocol/protocol_types.py src/lifx/products/registry.py
+        uv run ruff check --fix src/lifx/protocol/packets.py src/lifx/protocol/protocol_types.py src/lifx/products/registry.py
+
+    - name: Check for differences
+      run: |
+        if ! git diff --exit-code src/lifx/protocol/packets.py src/lifx/protocol/protocol_types.py src/lifx/products/registry.py; then
+          echo "::error::Generated files do not match committed versions. See diff above for details."
+          exit 1
+        fi
+        echo "All generated files are up-to-date."
+
   # Testing matrix across Python versions and platforms
   test:
     name: Test (Python ${{ matrix.python-version }} on ${{ matrix.os }})
@@ -72,12 +113,12 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ['3.11', '3.12', '3.13', '3.14']
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
     steps:
     - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -129,7 +170,7 @@ jobs:
     - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8   # v6
 
     - name: Set up Python
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548   # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405   # v6
       with:
         python-version: ${{ env.PYTHON_VERSION }}
 
@@ -167,6 +208,7 @@ jobs:
   release:
     needs:
     - quality
+    - generated-files
     - test
     # Run release if not cancelled AND (manual dispatch OR quality passed with tests passed/skipped)
     if: ${{ !cancelled() && (github.event_name == 'workflow_dispatch' || (needs.quality.result == 'success' && (needs.test.result == 'success' || needs.test.result == 'skipped'))) }}
@@ -193,7 +235,7 @@ jobs:
         ssh-key: ${{ secrets.DEPLOY_KEY }}
 
     - name: Set up Python
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       with:
         python-version: ${{ env.PYTHON_VERSION }}
 

{lifx_async-5.0.0 → lifx_async-5.1.0}/.github/workflows/docs.yml

@@ -30,7 +30,7 @@ jobs:
         fetch-depth: 0    # Fetch all history for git-revision-date-localized
 
     - name: Set up Python
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       with:
         python-version: ${{ env.PYTHON_VERSION }}
 
@@ -64,7 +64,7 @@ jobs:
         fetch-depth: 0
 
     - name: Set up Python
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       with:
         python-version: ${{ env.PYTHON_VERSION }}
 
@@ -92,7 +92,7 @@ jobs:
     - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6
 
     - name: Set up Python
-      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       with:
         python-version: ${{ env.PYTHON_VERSION }}
 

{lifx_async-5.0.0 → lifx_async-5.1.0}/CLAUDE.md

@@ -149,7 +149,17 @@ uv run mkdocs gh-deploy
    - `DeviceGroup`: Batch operations (set_power, set_color, etc.)
    - `LocationGrouping` / `GroupGrouping`: Organizational structures for location/group-based grouping
 
-5. **Utilities**
+5. **Animation Layer** (`src/lifx/animation/`)
+
+   - `animator.py`: High-level `Animator` class with direct UDP sending
+   - `framebuffer.py`: Multi-tile canvas mapping and orientation correction
+   - `packets.py`: Prebaked packet templates (`MatrixPacketGenerator`, `MultiZonePacketGenerator`)
+   - `orientation.py`: Tile orientation remapping with LRU-cached lookup tables
+   - Optimized for high-frequency frame delivery (30+ FPS) for real-time effects
+   - Uses protocol-ready uint16 HSBK values (no conversion overhead)
+   - Multi-tile canvas support using `user_x`/`user_y` tile positions
+
+6. **Utilities**
 
    - `color.py`: `HSBK` class with RGB conversion, `Colors` presets
    - `const.py`: Critical constants (network settings, UUIDs, official URLs)
@@ -481,6 +491,80 @@ for frame in animation_frames:
 
 **Note:** `MatrixLight.set64()` is already fire-and-forget by default.
 
+### Animation Module (High-Frequency Frame Delivery)
+
+For real-time effects and applications that need to push color data at 30+ FPS, use the animation module:
+
+```python
+from lifx import Animator, MatrixLight
+
+async with await MatrixLight.from_ip("192.168.1.100") as device:
+    # Create animator for matrix device
+    animator = await Animator.for_matrix(device)
+
+# Device connection closed - animator sends via direct UDP
+while running:
+    # Generate HSBK frame (protocol-ready uint16 values)
+    # H/S/B: 0-65535, K: 1500-9000
+    hsbk_frame = [(65535, 65535, 65535, 3500)] * animator.pixel_count
+
+    # send_frame() is synchronous for speed
+    stats = animator.send_frame(hsbk_frame)
+    print(f"Sent {stats.packets_sent} packets")
+
+    await asyncio.sleep(1 / 30)  # 30 FPS
+
+animator.close()
+```
+
+**Key Features:**
+- **Direct UDP**: Bypasses connection layer for maximum throughput
+- **Prebaked packets**: Templates created once, only colors updated per frame
+- **Multi-tile canvas**: Unified coordinate space for multi-tile devices (e.g., 5-tile LIFX Tile)
+- **Tile orientation**: Automatic pixel remapping for rotated tiles
+
+**Multi-Tile Canvas:**
+
+For devices with multiple tiles, the animator creates a unified canvas based on tile positions:
+
+```python
+async with await MatrixLight.from_ip("192.168.1.100") as device:
+    animator = await Animator.for_matrix(device)
+
+# For 5 horizontal tiles: canvas is 40x8 (320 pixels)
+print(f"Canvas: {animator.canvas_width}x{animator.canvas_height}")
+
+# Generate frame for entire canvas (row-major order)
+frame = []
+for y in range(animator.canvas_height):
+    for x in range(animator.canvas_width):
+        hue = int(x / animator.canvas_width * 65535)  # Rainbow across all tiles
+        frame.append((hue, 65535, 65535, 3500))
+
+animator.send_frame(frame)
+```
+
+**HSBK Format (Protocol-Ready):**
+```python
+# (hue, saturation, brightness, kelvin)
+# H/S/B: 0-65535, K: 1500-9000
+red = (0, 65535, 65535, 3500)           # Full red
+blue = (43690, 65535, 65535, 3500)      # Full blue (240/360 * 65535)
+white = (0, 0, 65535, 5500)             # Daylight white
+off = (0, 0, 0, 3500)                   # Off (black)
+```
+
+**For MultiZone devices (strips/beams):**
+```python
+from lifx import Animator, MultiZoneLight
+
+async with await MultiZoneLight.from_ip("192.168.1.100") as device:
+    animator = await Animator.for_multizone(device)
+
+# Same API as matrix
+stats = animator.send_frame(hsbk_frame)
+```
+
 ### Packet Flow
 
 1. Create packet instance (e.g., `LightSetColor`)

{lifx_async-5.0.0 → lifx_async-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 5.0.0
+Version: 5.1.0
 Summary: A modern, type-safe, async Python library for controlling LIFX lights
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

lifx_async-5.1.0/docs/api/animation.md

@@ -0,0 +1,356 @@
+# Animation Module
+
+The animation module provides efficient high-frequency frame delivery for LIFX devices, optimized
+for real-time effects and applications that need to push color data at 30+ FPS.
+
+## Overview
+
+The animation system uses a streamlined architecture optimized for speed:
+
+```
+Application Frame -> FrameBuffer -> PacketGenerator -> Direct UDP
+                     (canvas map)   (prebaked packets)  (fire-and-forget)
+```
+
+Key features:
+
+- **Direct UDP**: Bypasses connection layer for maximum throughput
+- **Prebaked packets**: Templates created once, only colors updated per frame
+- **Multi-tile canvas**: Unified coordinate space for multi-tile devices
+- **Tile orientation**: Automatic pixel remapping for rotated tiles
+- **Synchronous sending**: `send_frame()` is synchronous for minimum overhead
+
+## Quick Start
+
+```python
+import asyncio
+from lifx import Animator, MatrixLight
+
+async def main():
+    async with await MatrixLight.from_ip("192.168.1.100") as device:
+        # Create animator for matrix device
+        animator = await Animator.for_matrix(device)
+
+    # Device connection closed - animator sends via direct UDP
+    try:
+        while True:
+            # Generate HSBK frame (protocol-ready uint16 values)
+            # H/S/B: 0-65535, K: 1500-9000
+            hsbk_frame = [(65535, 65535, 65535, 3500)] * animator.pixel_count
+
+            # send_frame() is synchronous for speed
+            stats = animator.send_frame(hsbk_frame)
+            print(f"Sent {stats.packets_sent} packets in {stats.total_time_ms:.2f}ms")
+
+            await asyncio.sleep(1 / 30)  # 30 FPS
+    finally:
+        animator.close()
+```
+
+## Multi-Tile Canvas
+
+For devices with multiple tiles (like the original 5-tile LIFX Tile), the animator creates
+a unified canvas based on tile positions (`user_x`, `user_y`). Animations span all tiles
+as one continuous image.
+
+```python
+async with await MatrixLight.from_ip("192.168.1.100") as device:
+    animator = await Animator.for_matrix(device)
+
+# Check canvas dimensions
+print(f"Canvas: {animator.canvas_width}x{animator.canvas_height}")
+# For 5 horizontal tiles: "Canvas: 40x8"
+
+# Generate frame for entire canvas (row-major order)
+frame = []
+for y in range(animator.canvas_height):
+    for x in range(animator.canvas_width):
+        hue = int(x / animator.canvas_width * 65535)  # Gradient across all tiles
+        frame.append((hue, 65535, 65535, 3500))
+
+animator.send_frame(frame)
+```
+
+## HSBK Format
+
+All color data uses protocol-ready uint16 values:
+
+| Component | Range | Description |
+|-----------|-------|-------------|
+| Hue | 0-65535 | Maps to 0-360 degrees |
+| Saturation | 0-65535 | Maps to 0.0-1.0 |
+| Brightness | 0-65535 | Maps to 0.0-1.0 |
+| Kelvin | 1500-9000 | Color temperature |
+
+This design pushes conversion work to the caller (e.g. using NumPy) for better performance.
+The `lifx-async` library remains dependency-free.
+
+```python
+# Red at full brightness
+red = (0, 65535, 65535, 3500)
+
+# 50% brightness warm white
+warm_white = (0, 0, 32768, 2700)
+
+# Convert from user-friendly values
+def to_protocol_hsbk(
+    hue: float, sat: float, bright: float, kelvin: int
+) -> tuple[int, int, int, int]:
+    """Convert user-friendly values to protocol format."""
+    return (
+        int(hue / 360 * 65535),
+        int(sat * 65535),
+        int(bright * 65535),
+        kelvin,
+    )
+```
+
+## Animator
+
+High-level class integrating all animation components.
+
+::: lifx.animation.animator.Animator
+    options:
+      show_root_heading: true
+      heading_level: 3
+      members_order: source
+      show_if_no_docstring: false
+      filters:
+        - "!^_"
+
+### AnimatorStats
+
+Statistics returned by `Animator.send_frame()`.
+
+::: lifx.animation.animator.AnimatorStats
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+
+## FrameBuffer
+
+Canvas mapping and orientation handling for matrix devices.
+
+::: lifx.animation.framebuffer.FrameBuffer
+    options:
+      show_root_heading: true
+      heading_level: 3
+      members_order: source
+      show_if_no_docstring: false
+      filters:
+        - "!^_"
+
+### TileRegion
+
+Represents a tile's region within the canvas.
+
+::: lifx.animation.framebuffer.TileRegion
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+
+## Packet Generators
+
+Device-specific packet generation with prebaked templates.
+
+### PacketGenerator (Base)
+
+::: lifx.animation.packets.PacketGenerator
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+
+### PacketTemplate
+
+Prebaked packet template for zero-allocation frame updates.
+
+::: lifx.animation.packets.PacketTemplate
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+
+### MatrixPacketGenerator
+
+Generates Set64 packets for MatrixLight devices.
+
+::: lifx.animation.packets.MatrixPacketGenerator
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+      filters:
+        - "!^_"
+
+### MultiZonePacketGenerator
+
+Generates SetExtendedColorZones packets for MultiZoneLight devices.
+
+::: lifx.animation.packets.MultiZonePacketGenerator
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+      filters:
+        - "!^_"
+
+## Tile Orientation
+
+Pixel remapping for rotated tiles.
+
+### Orientation Enum
+
+::: lifx.animation.orientation.Orientation
+    options:
+      show_root_heading: true
+      heading_level: 4
+      members_order: source
+      show_if_no_docstring: false
+
+### build_orientation_lut
+
+::: lifx.animation.orientation.build_orientation_lut
+    options:
+      show_root_heading: true
+      heading_level: 4
+
+## Examples
+
+### Matrix Animation (Single Tile)
+
+```python
+import asyncio
+from lifx import Animator, MatrixLight
+
+async def rainbow_animation():
+    async with await MatrixLight.from_ip("192.168.1.100") as device:
+        animator = await Animator.for_matrix(device)
+
+    hue_offset = 0
+    try:
+        while True:
+            # Generate rainbow gradient
+            frame = []
+            for i in range(animator.pixel_count):
+                hue = (hue_offset + i * 1000) % 65536
+                frame.append((hue, 65535, 32768, 3500))
+
+            stats = animator.send_frame(frame)
+            print(f"Sent {stats.packets_sent} packets")
+
+            hue_offset = (hue_offset + 500) % 65536
+            await asyncio.sleep(1 / 30)  # 30 FPS
+    finally:
+        animator.close()
+```
+
+### Multi-Tile Animation (LIFX Tile with 5 tiles)
+
+```python
+import asyncio
+import math
+from lifx import Animator, MatrixLight
+
+async def multi_tile_wave():
+    async with await MatrixLight.from_ip("192.168.1.100") as device:
+        animator = await Animator.for_matrix(device)
+
+    # Canvas spans all tiles (e.g., 40x8 for 5 horizontal tiles)
+    width = animator.canvas_width
+    height = animator.canvas_height
+    print(f"Canvas: {width}x{height}")
+
+    hue_offset = 0
+    try:
+        while True:
+            frame = []
+            for y in range(height):
+                for x in range(width):
+                    # Wave that flows across all tiles
+                    pos = x + y * 0.5  # Diagonal wave
+                    hue = int((pos / width) * 65535 + hue_offset) % 65536
+                    frame.append((hue, 65535, 65535, 3500))
+
+            animator.send_frame(frame)
+            hue_offset = (hue_offset + 1000) % 65536
+            await asyncio.sleep(1 / 30)
+    finally:
+        animator.close()
+```
+
+### MultiZone Animation
+
+```python
+import asyncio
+from lifx import Animator, MultiZoneLight
+
+async def chase_animation():
+    async with await MultiZoneLight.from_ip("192.168.1.100") as device:
+        animator = await Animator.for_multizone(device)
+
+    position = 0
+    try:
+        while True:
+            # Generate chase pattern
+            frame = []
+            for i in range(animator.pixel_count):
+                if i == position:
+                    frame.append((0, 65535, 65535, 3500))  # Red
+                else:
+                    frame.append((0, 0, 0, 3500))  # Off
+
+            animator.send_frame(frame)
+
+            position = (position + 1) % animator.pixel_count
+            await asyncio.sleep(1 / 20)  # 20 FPS
+    finally:
+        animator.close()
+```
+
+## Performance Characteristics
+
+### Direct UDP Delivery
+
+The animation module bypasses the connection layer entirely:
+
+- No ACKs, no waiting, no retries
+- Packets sent via raw UDP socket
+- Maximum throughput for real-time effects
+- Some packet loss is acceptable (visual artifacts are brief)
+
+### Prebaked Packet Templates
+
+Packets are constructed once at initialization:
+
+- Header and payload structure prebaked as `bytearray`
+- Per-frame: only color data and sequence number updated
+- Zero object allocation in the hot path
+- Sequence number wraps at 256 (uint8)
+
+### Multi-Tile Canvas Mapping
+
+For devices with multiple tiles:
+
+- Tile positions read from device (`user_x`, `user_y`)
+- Canvas bounds calculated from all tile positions
+- Input frame interpreted as 2D row-major canvas
+- Each tile extracts its region based on position
+- Orientation correction applied per-tile
+
+### Typical Performance
+
+| Device Type | Pixels | Packets/Frame | Send Time |
+|-------------|--------|---------------|-----------|
+| Single tile (8x8) | 64 | 1 | <0.5ms |
+| 5-tile chain | 320 | 5 | <1ms |
+| Large Ceiling (16x8) | 128 | 3 | <1ms |
+| MultiZone (82 zones) | 82 | 1 | <0.5ms |

{lifx_async-5.0.0 → lifx_async-5.1.0}/docs/api/index.md

@@ -11,6 +11,12 @@ lifx/
 ├── color.py                  # Color utilities (HSBK, Colors)
 ├── const.py                  # Network constants and URLs
 ├── exceptions.py             # Exception hierarchy
+├── animation/                # Animation module for high-frequency frame delivery
+│   ├── __init__.py          # Public API exports
+│   ├── animator.py          # High-level Animator class with direct UDP
+│   ├── framebuffer.py       # Multi-tile canvas mapping and orientation
+│   ├── packets.py           # Prebaked packet templates
+│   └── orientation.py       # Tile orientation remapping
 ├── devices/                  # Device classes
 │   ├── base.py              # Base Device class
 │   ├── light.py             # Light device (color control)
@@ -73,6 +79,14 @@ Work with colors:
 - [`HSBK`](colors.md#lifx.color.HSBK) - Color representation
 - [`Colors`](colors.md#lifx.color.Colors) - Built-in presets
 
+### Animation
+
+High-frequency frame delivery for real-time effects:
+
+- [`Animator`](animation.md#lifx.animation.animator.Animator) - High-level animation interface with direct UDP
+- [`FrameBuffer`](animation.md#lifx.animation.framebuffer.FrameBuffer) - Multi-tile canvas mapping
+- [`PacketTemplate`](animation.md#lifx.animation.packets.PacketTemplate) - Prebaked packet templates
+
 ### Network Layer
 
 Low-level network operations:
@@ -195,6 +209,14 @@ async def set_custom_color(light: Light, hue: float) -> None:
 
   [:octicons-arrow-right-24: Colors](colors.md)
 
+- :material-animation:{ .lg .middle } __Animation__
+
+  ______________________________________________________________________
+
+  High-frequency frame delivery for real-time effects
+
+  [:octicons-arrow-right-24: Animation](animation.md)
+
 - :material-network:{ .lg .middle } __Network Layer__
 
   ______________________________________________________________________

{lifx_async-5.0.0 → lifx_async-5.1.0}/docs/api/protocol.md

@@ -30,19 +30,6 @@ The LIFX protocol header structure (36 bytes).
       members_order: source
       show_if_no_docstring: false
 
-## Serializer
-
-Binary serialization and deserialization utilities.
-
-::: lifx.protocol.serializer.FieldSerializer
-    options:
-      show_root_heading: true
-      heading_level: 3
-      members_order: source
-      show_if_no_docstring: false
-      filters:
-        - "!^_"
-
 ## Protocol Types
 
 Common protocol type definitions and enums.
@@ -241,7 +228,6 @@ async def main():
 
 ```python
 from lifx.protocol.packets import DeviceSetLabel
-from lifx.protocol.serializer import Serializer
 
 # Create packet
 packet = DeviceSetLabel(label=b"Kitchen Light\0" + b"\0" * 19)

{lifx_async-5.0.0 → lifx_async-5.1.0}/docs/changelog.md

@@ -2,6 +2,35 @@
 
 <!-- version list -->
 
+## v5.1.0 (2026-01-24)
+
+### Bug Fixes
+
+- **animation**: Load capabilities before checking has_chain
+  ([`69e50b3`](https://github.com/Djelibeybi/lifx-async/commit/69e50b356ed22ad1679a823444db9fa7c19626b7))
+
+### Documentation
+
+- Add DeviceGroup usage example
+  ([`9f85854`](https://github.com/Djelibeybi/lifx-async/commit/9f858543f745140c154128c63006047fccdbd823))
+
+- Remove reference to deleted FieldSerializer class
+  ([`5db0262`](https://github.com/Djelibeybi/lifx-async/commit/5db0262b593121be2de00bba44d522e11e449845))
+
+### Features
+
+- **animation**: Add high-performance animation module
+  ([`afc8063`](https://github.com/Djelibeybi/lifx-async/commit/afc8063e6d863e118377facab30a7d3035b1ded5))
+
+
+## v5.0.1 (2026-01-14)
+
+### Bug Fixes
+
+- Handle asyncio.TimeoutError on Python 3.10
+  ([`4438bc4`](https://github.com/Djelibeybi/lifx-async/commit/4438bc45f19f477b585c6af8cf8cbaf5e9341d14))
+
+
 ## v5.0.0 (2026-01-12)
 
 ### Features