lifx-async 4.3.2__tar.gz → 4.3.4__tar.gz

{lifx_async-4.3.2 → lifx_async-4.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 4.3.2
+Version: 4.3.4
 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-4.3.2 → lifx_async-4.3.4}/docs/changelog.md

@@ -2,6 +2,25 @@
 
 <!-- version list -->
 
+## v4.3.4 (2025-11-22)
+
+### Bug Fixes
+
+- **network**: Exclude retry sleep time from timeout budget
+  ([`312d7a7`](https://github.com/Djelibeybi/lifx-async/commit/312d7a7e2561de7d2bbf142c8a521daca31651bb))
+
+
+## v4.3.3 (2025-11-22)
+
+### Bug Fixes
+
+- Give MatrixLight.get64() some default parameters
+  ([`a69a49c`](https://github.com/Djelibeybi/lifx-async/commit/a69a49c93488c79c8c3be58a9304fd01b4b12231))
+
+- **themes**: Apply theme colors to all zones via proper canvas interpolation
+  ([`f1628c4`](https://github.com/Djelibeybi/lifx-async/commit/f1628c4a071d257d7db79a7945d1516c783d8d52))
+
+
 ## v4.3.2 (2025-11-22)
 
 ### Bug Fixes

{lifx_async-4.3.2 → lifx_async-4.3.4}/examples/11_matrix_basic.py

@@ -35,9 +35,7 @@ async def main(ip: str):
 
         # Get current colors from first tile
         print("Getting current colors from tile 0...")
-        tile_colors = await matrix.get64(
-            tile_index=0, length=1, x=0, y=0, width=device_chain[0].width
-        )
+        tile_colors = await matrix.get64()
         print(f"Retrieved {len(tile_colors)} colors\n")
 
         if power == 0:

{lifx_async-4.3.2 → lifx_async-4.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-async"
-version = "4.3.2"
+version = "4.3.4"
 description = "A modern, type-safe, async Python library for controlling LIFX lights"
 readme = "README.md"
 requires-python = ">=3.11"

{lifx_async-4.3.2 → lifx_async-4.3.4}/src/lifx/devices/base.py

@@ -252,6 +252,8 @@ class Device:
         self.serial = serial_obj.to_string()
         self.ip = ip
         self.port = port
+        self._timeout = timeout
+        self._max_retries = max_retries
 
         # Create lightweight connection handle - connection pooling is internal
         self.connection = DeviceConnection(
@@ -304,10 +306,16 @@ class Device:
             ```
         """
         if serial is None:
-            temp_conn = DeviceConnection(serial="000000000000", ip=ip, port=port)
+            temp_conn = DeviceConnection(
+                serial="000000000000",
+                ip=ip,
+                port=port,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
             try:
                 response = await temp_conn.request(
-                    packets.Device.GetService(), timeout=DISCOVERY_TIMEOUT
+                    packets.Device.GetService(), timeout=timeout
                 )
                 if response and isinstance(response, packets.Device.StateService):
                     if temp_conn.serial and temp_conn.serial != "000000000000":
@@ -890,9 +898,17 @@ class Device:
 
         try:
             # Check each device for the target label
-            async for disc in discover_devices(timeout=discover_timeout):
+            async for disc in discover_devices(
+                timeout=discover_timeout,
+                device_timeout=self._timeout,
+                max_retries=self._max_retries,
+            ):
                 temp_conn = DeviceConnection(
-                    serial=disc.serial, ip=disc.ip, port=disc.port
+                    serial=disc.serial,
+                    ip=disc.ip,
+                    port=disc.port,
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
                 )
 
                 try:
@@ -1063,9 +1079,17 @@ class Device:
 
         try:
             # Check each device for the target label
-            async for disc in discover_devices(timeout=discover_timeout):
+            async for disc in discover_devices(
+                timeout=discover_timeout,
+                device_timeout=self._timeout,
+                max_retries=self._max_retries,
+            ):
                 temp_conn = DeviceConnection(
-                    serial=disc.serial, ip=disc.ip, port=disc.port
+                    serial=disc.serial,
+                    ip=disc.ip,
+                    port=disc.port,
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
                 )
 
                 try:

{lifx_async-4.3.2 → lifx_async-4.3.4}/src/lifx/devices/matrix.py

@@ -371,45 +371,58 @@ class MatrixLight(Light):
 
     async def get64(
         self,
-        tile_index: int,
-        length: int,
-        x: int,
-        y: int,
-        width: int,
-        fb_index: int = 0,
+        tile_index: int = 0,
+        length: int = 1,
+        x: int = 0,
+        y: int = 0,
+        width: int | None = None,
     ) -> list[HSBK]:
         """Get up to 64 zones of color state from a tile.
 
+        For devices with ≤64 zones, returns all zones. For devices with >64 zones,
+        returns up to 64 zones due to protocol limitations.
+
         Args:
-            tile_index: Index of the tile (0-based)
-            length: Number of tiles to query (usually 1)
-            x: X coordinate of the rectangle (0-based)
-            y: Y coordinate of the rectangle (0-based)
-            width: Width of the rectangle in zones
-            fb_index: Frame buffer index (0 for display, 1 for temp buffer)
+            tile_index: Index of the tile (0-based). Defaults to 0.
+            length: Number of tiles to query (usually 1). Defaults to 1.
+            x: X coordinate of the rectangle (0-based). Defaults to 0.
+            y: Y coordinate of the rectangle (0-based). Defaults to 0.
+            width: Width of the rectangle in zones. Defaults to tile width.
 
         Returns:
-            List of HSBK colors for the requested zones
+            List of HSBK colors for the requested zones. For tiles with ≤64 zones,
+            returns the actual zone count (e.g., 64 for 8x8, 16 for 4x4). For tiles
+            with >64 zones (e.g., 128 for 16x8 Ceiling), returns 64 (protocol limit).
 
         Example:
-            >>> # Get colors from 8x8 tile (64 zones)
-            >>> colors = await matrix.get64(tile_index=0, length=1, x=0, y=0, width=8)
+            >>> # Get all colors from first tile (no parameters needed)
+            >>> colors = await matrix.get64()
+            >>>
+            >>> # Get colors from specific region
+            >>> colors = await matrix.get64(y=4)  # Start at row 4
         """
         # Validate parameters
         if x < 0:
             raise ValueError(f"x coordinate must be non-negative, got {x}")
         if y < 0:
             raise ValueError(f"y coordinate must be non-negative, got {y}")
-        if width <= 0:
+        if width is not None and width <= 0:
             raise ValueError(f"width must be positive, got {width}")
 
+        if self._device_chain is None:
+            device_chain = await self.get_device_chain()
+        else:
+            device_chain = self._device_chain
+
+        if width is None:
+            width = device_chain[0].width
+
         _LOGGER.debug(
-            "Getting 64 zones from tile %d (x=%d, y=%d, width=%d, fb=%d) for %s",
+            "Getting 64 zones from tile %d (x=%d, y=%d, width=%d) for %s",
             tile_index,
             x,
             y,
             width,
-            fb_index,
             self.label or self.serial,
         )
 
@@ -417,12 +430,17 @@ class MatrixLight(Light):
             packets.Tile.Get64(
                 tile_index=tile_index,
                 length=length,
-                rect=TileBufferRect(fb_index=fb_index, x=x, y=y, width=width),
+                rect=TileBufferRect(fb_index=0, x=x, y=y, width=width),
             )
         )
 
+        max_colors = device_chain[0].width * device_chain[0].height
+
         # Convert protocol colors to HSBK
-        return [HSBK.from_protocol(proto_color) for proto_color in response.colors]
+        return [
+            HSBK.from_protocol(proto_color)
+            for proto_color in response.colors[:max_colors]
+        ]
 
     async def set64(
         self,
@@ -504,7 +522,11 @@ class MatrixLight(Light):
         )
 
     async def copy_frame_buffer(
-        self, tile_index: int, source_fb: int = 1, target_fb: int = 0
+        self,
+        tile_index: int,
+        source_fb: int = 1,
+        target_fb: int = 0,
+        duration: float = 0.0,
     ) -> None:
         """Copy frame buffer (for tiles with >64 zones).
 
@@ -515,6 +537,7 @@ class MatrixLight(Light):
             tile_index: Index of the tile (0-based)
             source_fb: Source frame buffer index (usually 1)
             target_fb: Target frame buffer index (usually 0)
+            duration: time in seconds to transition if target_fb is 0
 
         Example:
             >>> # For 16x8 tile (128 zones):
@@ -541,7 +564,9 @@ class MatrixLight(Light):
             ...     fb_index=1,
             ... )
             >>> # 3. Copy buffer 1 to buffer 0 (display)
-            >>> await matrix.copy_frame_buffer(tile_index=0, source_fb=1, target_fb=0)
+            >>> await matrix.copy_frame_buffer(
+            ...     tile_index=0, source_fb=1, target_fb=0, duration=2.0
+            ... )
         """
         _LOGGER.debug(
             "Copying frame buffer %d -> %d for tile %d on %s",
@@ -559,6 +584,7 @@ class MatrixLight(Light):
             raise ValueError(f"Invalid tile_index {tile_index}")
 
         tile = self._device_chain[tile_index]
+        duration_ms = round(duration * 1000 if duration else 0)
 
         await self.connection.send_packet(
             packets.Tile.CopyFrameBuffer(
@@ -572,7 +598,7 @@ class MatrixLight(Light):
                 dst_y=0,
                 width=tile.width,
                 height=tile.height,
-                duration=0,
+                duration=duration_ms,
             )
         )
 
@@ -723,7 +749,7 @@ class MatrixLight(Light):
     async def set_effect(
         self,
         effect_type: FirmwareEffect,
-        speed: int = 3000,
+        speed: float = 3.0,
         duration: int = 0,
         palette: list[HSBK] | None = None,
         sky_type: TileEffectSkyType = TileEffectSkyType.SUNRISE,
@@ -734,7 +760,7 @@ class MatrixLight(Light):
 
         Args:
             effect_type: Type of effect (OFF, MORPH, FLAME, SKY)
-            speed: Effect speed in milliseconds (default: 3000)
+            speed: Effect speed in seconds (default: 3)
             duration: Total effect duration in nanoseconds (0 for infinite)
             palette: Color palette for the effect (max 16 colors)
             sky_type: Sky effect type (SUNRISE, SUNSET, CLOUDS)
@@ -751,7 +777,7 @@ class MatrixLight(Light):
             ... ]
             >>> await matrix.set_effect(
             ...     effect_type=FirmwareEffect.MORPH,
-            ...     speed=5000,
+            ...     speed=5.0,
             ...     palette=rainbow,
             ... )
         """
@@ -761,11 +787,12 @@ class MatrixLight(Light):
             speed,
             self.label or self.serial,
         )
+        speed_ms = round(speed * 1000) if speed else 3000
 
         # Create and validate MatrixEffect
         effect = MatrixEffect(
             effect_type=effect_type,
-            speed=speed,
+            speed=speed_ms,
             duration=duration,
             palette=palette,
             sky_type=sky_type,
@@ -843,9 +870,23 @@ class MatrixLight(Light):
         # Create canvas and populate with theme colors
         canvas = Canvas()
         for tile in tiles:
-            canvas.add_points_for_tile(None, theme)
-        canvas.shuffle_points()
-        canvas.blur_by_distance()
+            canvas.add_points_for_tile((int(tile.user_x), int(tile.user_y)), theme)
+            canvas.shuffle_points()
+            canvas.blur_by_distance()
+
+        # Create tile canvas and fill in gaps for smooth interpolation
+        tile_canvas = Canvas()
+        for tile in tiles:
+            tile_canvas.fill_in_points(
+                canvas,
+                int(tile.user_x),
+                int(tile.user_y),
+                tile.width,
+                tile.height,
+            )
+
+        # Final blur for smooth gradients
+        tile_canvas.blur()
 
         # Check if light is on
         is_on = await self.get_power()
@@ -853,7 +894,10 @@ class MatrixLight(Light):
         # Apply colors to each tile
         for tile in tiles:
             # Extract tile colors from canvas as 1D list
-            colors = canvas.points_for_tile(None, width=tile.width, height=tile.height)
+            tile_coords = (int(tile.user_x), int(tile.user_y))
+            colors = tile_canvas.points_for_tile(
+                tile_coords, width=tile.width, height=tile.height
+            )
 
             # Apply with appropriate timing
             if power_on and not is_on:

{lifx_async-4.3.2 → lifx_async-4.3.4}/src/lifx/network/connection.py

@@ -467,13 +467,10 @@ class DeviceConnection:
         correlation_keys: list[tuple[int, int, str]] = []
 
         # Calculate per-attempt timeouts with exponential backoff
-        # Start with a reasonable minimum (100ms) to avoid too-short initial timeouts
-        min_attempt_timeout = 0.1  # 100ms minimum
-        if max_retries > 0:
-            attempt_timeout = max(min_attempt_timeout, timeout / (2 * max_retries))
-        else:
-            # Only one attempt total, use entire timeout
-            attempt_timeout = timeout
+        # Use proper exponential backoff distribution: timeout / (2^(n+1) - 1)
+        # This ensures total of all attempt timeouts equals the overall timeout budget
+        total_weight = (2 ** (max_retries + 1)) - 1
+        base_timeout = timeout / total_weight
 
         # Idle timeout for multi-response protocols
         # Stop streaming if no responses for this long after first response
@@ -482,14 +479,17 @@ class DeviceConnection:
         last_error: Exception | None = None
         has_yielded = False
         overall_start = time.monotonic()
+        total_sleep_time = 0.0  # Track sleep time to exclude from timeout budget
 
         try:
             for attempt in range(max_retries + 1):
                 # Calculate current attempt timeout with exponential backoff
-                current_timeout = min(
-                    attempt_timeout * (2**attempt),
-                    timeout - (time.monotonic() - overall_start),
+                # Exclude sleep time from elapsed time to preserve timeout budget
+                elapsed_response_time = (
+                    time.monotonic() - overall_start - total_sleep_time
                 )
+                ideal_timeout = base_timeout * (2**attempt)
+                current_timeout = min(ideal_timeout, timeout - elapsed_response_time)
 
                 # Check if we've exceeded overall timeout budget
                 if current_timeout <= 0:
@@ -616,6 +616,9 @@ class DeviceConnection:
                         # Sleep with jitter before retry
                         sleep_time = self._calculate_retry_sleep_with_jitter(attempt)
                         await asyncio.sleep(sleep_time)
+                        total_sleep_time += (
+                            sleep_time  # Track sleep to exclude from timeout
+                        )
                         continue
                     else:
                         # All retries exhausted
@@ -673,9 +676,14 @@ class DeviceConnection:
         base_timeout = timeout / total_weight
 
         last_error: Exception | None = None
+        total_sleep_time = 0.0  # Track sleep time to exclude from timeout budget
+        overall_start = time.monotonic()
 
         for attempt in range(max_retries + 1):
-            current_timeout = base_timeout * (2**attempt)
+            # Calculate timeout with budget remaining after excluding sleep time
+            elapsed_response_time = time.monotonic() - overall_start - total_sleep_time
+            ideal_timeout = base_timeout * (2**attempt)
+            current_timeout = min(ideal_timeout, timeout - elapsed_response_time)
             sequence = attempt
 
             # Correlation key: (source, sequence, serial)
@@ -737,6 +745,9 @@ class DeviceConnection:
                     # Sleep with jitter before retry
                     sleep_time = self._calculate_retry_sleep_with_jitter(attempt)
                     await asyncio.sleep(sleep_time)
+                    total_sleep_time += (
+                        sleep_time  # Track sleep to exclude from timeout
+                    )
                     continue
                 else:
                     break

{lifx_async-4.3.2 → lifx_async-4.3.4}/tests/test_devices/test_base.py

@@ -527,7 +527,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_location)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -537,8 +537,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            # First call: discovered device, second call: this device
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_location(label)
 
@@ -581,7 +583,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_location)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -591,7 +593,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_location(label)
 
@@ -629,7 +634,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_group)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -639,7 +644,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_group(label)
 
@@ -682,7 +690,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_group)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -692,7 +700,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_group(label)