lifx-async 4.3.3__tar.gz → 4.3.5__tar.gz

{lifx_async-4.3.3 → lifx_async-4.3.5}/PKG-INFO

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

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v4.3.5 (2025-11-22)
+
+### Bug Fixes
+
+- **devices**: Allow MatrixEffect without palette
+  ([`fb31df5`](https://github.com/Djelibeybi/lifx-async/commit/fb31df51b1af9d8c7c2f573ec9619566b4f7393b))
+
+
+## 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

{lifx_async-4.3.3 → lifx_async-4.3.5}/pyproject.toml

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

{lifx_async-4.3.3 → lifx_async-4.3.5}/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.3 → lifx_async-4.3.5}/src/lifx/devices/matrix.py

@@ -171,11 +171,6 @@ class MatrixEffect:
 
     def __post_init__(self) -> None:
         """Initialize defaults and validate fields."""
-        # Initialize default palette if not provided
-        if self.palette is None:
-            # Default palette: single white color
-            self.palette = [HSBK(0, 0, 1.0, 3500)]
-
         # Validate all fields
         # Speed can be 0 only when effect is OFF
         if self.effect_type != FirmwareEffect.OFF:
@@ -184,7 +179,11 @@ class MatrixEffect:
             raise ValueError(f"Effect speed must be non-negative, got {self.speed}")
 
         self._validate_duration(self.duration)
-        self._validate_palette(self.palette)
+
+        # Only validate palette if provided
+        if self.palette is not None:
+            self._validate_palette(self.palette)
+
         self._validate_saturation(self.cloud_saturation_min, "cloud_saturation_min")
         self._validate_saturation(self.cloud_saturation_max, "cloud_saturation_max")
 
@@ -762,7 +761,7 @@ class MatrixLight(Light):
             effect_type: Type of effect (OFF, MORPH, FLAME, SKY)
             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)
+            palette: Color palette for the effect (max 16 colors, None for no palette)
             sky_type: Sky effect type (SUNRISE, SUNSET, CLOUDS)
             cloud_saturation_min: Minimum cloud saturation (0-255, for CLOUDS)
             cloud_saturation_max: Maximum cloud saturation (0-255, for CLOUDS)
@@ -780,6 +779,12 @@ class MatrixLight(Light):
             ...     speed=5.0,
             ...     palette=rainbow,
             ... )
+
+            >>> # Set effect without a palette
+            >>> await matrix.set_effect(
+            ...     effect_type=FirmwareEffect.FLAME,
+            ...     speed=3.0,
+            ... )
         """
         _LOGGER.debug(
             "Setting matrix effect %s (speed=%d) for %s",
@@ -801,20 +806,22 @@ class MatrixLight(Light):
         )
 
         # Convert to protocol format
-        # Note: palette is guaranteed to be non-None by MatrixEffect.__post_init__
-        palette = effect.palette if effect.palette is not None else []
         proto_palette = []
-        for color in palette:
-            proto_palette.append(
-                LightHsbk(
-                    hue=int(color.hue / 360 * 65535),
-                    saturation=int(color.saturation * 65535),
-                    brightness=int(color.brightness * 65535),
-                    kelvin=color.kelvin,
+        palette_count = 0
+
+        if effect.palette is not None:
+            palette_count = len(effect.palette)
+            for color in effect.palette:
+                proto_palette.append(
+                    LightHsbk(
+                        hue=int(color.hue / 360 * 65535),
+                        saturation=int(color.saturation * 65535),
+                        brightness=int(color.brightness * 65535),
+                        kelvin=color.kelvin,
+                    )
                 )
-            )
 
-        # Pad palette to 16 colors
+        # Pad palette to 16 colors (protocol requirement)
         while len(proto_palette) < 16:
             proto_palette.append(LightHsbk(0, 0, 0, 3500))
 
@@ -828,7 +835,7 @@ class MatrixLight(Light):
                 cloud_saturation_min=effect.cloud_saturation_min,
                 cloud_saturation_max=effect.cloud_saturation_max,
             ),
-            palette_count=len(palette),
+            palette_count=palette_count,
             palette=proto_palette,
         )
 

{lifx_async-4.3.3 → lifx_async-4.3.5}/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.3 → lifx_async-4.3.5}/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)
 

{lifx_async-4.3.3 → lifx_async-4.3.5}/tests/test_devices/test_matrix.py

@@ -177,8 +177,9 @@ class TestMatrixLight:
             assert isinstance(effect.effect_type, FirmwareEffect)
             assert effect.speed >= 0
             assert effect.duration >= 0
-            assert effect.palette is not None
-            assert len(effect.palette) > 0
+            # Palette can be None if palette_count is 0
+            if effect.palette is not None:
+                assert len(effect.palette) > 0
 
     async def test_tile_effect_cached_property(self, emulator_devices) -> None:
         """Test tile_effect property caching."""
@@ -321,6 +322,21 @@ class TestMatrixLight:
             effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.OFF
 
+    async def test_set_effect_without_palette(self, emulator_devices) -> None:
+        """Test setting effect without a palette (palette_count=0)."""
+        matrix = emulator_devices[6]
+        async with matrix:
+            # Set effect without palette - should send palette_count=0
+            await matrix.set_effect(
+                effect_type=FirmwareEffect.MORPH,
+                speed=3000,
+            )
+
+            # Verify effect was set
+            effect = await matrix.get_effect()
+            assert effect.effect_type == FirmwareEffect.MORPH
+            assert effect.palette is None
+
     async def test_get64_large_tile(self, ceiling_device) -> None:
         """Test getting colors from 16x8 tile (128 zones) with default parameters.
 
@@ -553,15 +569,13 @@ class TestMatrixEffect:
         assert effect.palette is not None
         assert len(effect.palette) == 1
 
-    def test_effect_default_palette(self) -> None:
-        """Test that default palette is created if not provided."""
+    def test_effect_none_palette(self) -> None:
+        """Test that palette can be None (no palette specified)."""
         effect = MatrixEffect(
             effect_type=FirmwareEffect.MORPH,
             speed=3000,
         )
-        assert effect.palette is not None
-        assert len(effect.palette) == 1
-        assert isinstance(effect.palette[0], HSBK)
+        assert effect.palette is None
 
     def test_effect_validation_negative_speed(self) -> None:
         """Test that negative speed raises error."""