lifx-async 4.7.2__tar.gz → 4.7.3__tar.gz

{lifx_async-4.7.2 → lifx_async-4.7.3}/PKG-INFO

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

@@ -2,6 +2,14 @@
 
 <!-- version list -->
 
+## v4.7.3 (2025-12-16)
+
+### Bug Fixes
+
+- **devices**: Capture component colors before set_power turns off light
+  ([`a99abee`](https://github.com/Djelibeybi/lifx-async/commit/a99abeeeb4f6cad1e49410204b8e7a567765b3ed))
+
+
 ## v4.7.2 (2025-12-16)
 
 ### Bug Fixes

{lifx_async-4.7.2 → lifx_async-4.7.3}/pyproject.toml

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

{lifx_async-4.7.2 → lifx_async-4.7.3}/src/lifx/devices/ceiling.py

@@ -619,6 +619,65 @@ class CeilingLight(MatrixLight):
             determined_colors = await self._determine_downlight_brightness()
             await self.set_downlight_colors(determined_colors, duration)
 
+    async def set_power(self, level: bool | int, duration: float = 0.0) -> None:
+        """Set light power state, capturing component colors before turning off.
+
+        Overrides Light.set_power() to capture the current uplight and downlight
+        colors before turning off the entire light. This allows subsequent calls
+        to turn_uplight_on() or turn_downlight_on() to restore the colors that
+        were active just before the light was turned off.
+
+        The captured colors preserve hue, saturation, and kelvin values even if
+        a component was already off (brightness=0). The brightness will be
+        determined at turn-on time using the standard brightness inference logic.
+
+        Args:
+            level: True/65535 to turn on, False/0 to turn off
+            duration: Transition duration in seconds (default 0.0)
+
+        Raises:
+            ValueError: If integer value is not 0 or 65535
+            LifxDeviceNotFoundError: If device is not connected
+            LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
+
+        Example:
+            ```python
+            # Turn off entire ceiling light (captures colors for later)
+            await ceiling.set_power(False)
+
+            # Later, turn on just the uplight with its previous color
+            await ceiling.turn_uplight_on()
+
+            # Or turn on just the downlight with its previous colors
+            await ceiling.turn_downlight_on()
+            ```
+        """
+        # Determine if we're turning off
+        if isinstance(level, bool):
+            turning_off = not level
+        elif isinstance(level, int):
+            if level not in (0, 65535):
+                raise ValueError(f"Power level must be 0 or 65535, got {level}")
+            turning_off = level == 0
+        else:
+            raise TypeError(f"Expected bool or int, got {type(level).__name__}")
+
+        # If turning off, capture current colors for both components
+        if turning_off:
+            # Always capture colors - even if brightness is 0, the hue/sat/kelvin
+            # are still useful for turn_on. Brightness will be determined at
+            # turn-on time using the standard inference logic.
+            self._stored_uplight_state = await self.get_uplight_color()
+            self._stored_downlight_state = await self.get_downlight_colors()
+
+            # Persist if enabled
+            if self._state_file:
+                self._save_state_to_file()
+
+        # Call parent to perform actual power change
+        await super().set_power(level, duration)
+
     async def turn_downlight_off(
         self, colors: HSBK | list[HSBK] | None = None, duration: float = 0.0
     ) -> None:

{lifx_async-4.7.2 → lifx_async-4.7.3}/tests/test_devices/test_ceiling.py

@@ -5,12 +5,13 @@ from __future__ import annotations
 import json
 import tempfile
 from pathlib import Path
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
 from lifx.color import HSBK
 from lifx.devices.ceiling import CeilingLight
+from lifx.devices.matrix import MatrixLight
 from lifx.exceptions import LifxError
 from lifx.products import get_ceiling_layout
 
@@ -1646,3 +1647,237 @@ class TestCeilingLightSetDownlightSingleZeroBrightness:
 
         with pytest.raises(ValueError, match="brightness"):
             await ceiling_176.set_downlight_colors(invalid_color)
+
+
+class TestCeilingLightSetPowerOverride:
+    """Tests for set_power() override in CeilingLight."""
+
+    @pytest.fixture
+    def ceiling_176(self) -> CeilingLight:
+        """Create a Ceiling product 176 instance with mocked connection."""
+        ceiling = CeilingLight(serial="d073d5010203", ip="192.168.1.100")
+        ceiling.connection = AsyncMock()
+        ceiling.set_matrix_colors = AsyncMock()
+        ceiling._save_state_to_file = MagicMock()
+
+        white = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=3500)
+        default_tile_colors = [white] * 64
+        ceiling.get_all_tile_colors = AsyncMock(return_value=[default_tile_colors])
+
+        ceiling._version = MagicMock()
+        ceiling._version.product = 176
+        return ceiling
+
+    async def test_set_power_off_captures_uplight_color(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power(False) captures uplight color before turning off."""
+        # Setup: uplight is on with a specific color
+        uplight_color = HSBK(hue=120, saturation=0.8, brightness=0.75, kelvin=4000)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+
+        # Downlight is off (brightness=0) but still has hue/sat/kelvin
+        downlight_off = [
+            HSBK(hue=200, saturation=0.5, brightness=0.0, kelvin=3500)
+        ] * 16
+        ceiling_176.get_downlight_colors = AsyncMock(return_value=downlight_off)
+
+        # Mock the parent set_power call
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(False)
+
+            # Parent should be called
+            mock_parent.assert_called_once_with(False, 0.0)
+
+        # Both colors should be stored (regardless of brightness)
+        assert ceiling_176._stored_uplight_state == uplight_color
+        assert ceiling_176._stored_downlight_state == downlight_off
+
+        # State file should NOT be saved (no state_file set in fixture)
+        ceiling_176._save_state_to_file.assert_not_called()
+
+    async def test_set_power_off_captures_downlight_colors(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power(False) captures downlight colors before turning off."""
+        # Setup: uplight is off (brightness=0) but still has hue/sat/kelvin
+        uplight_off = HSBK(hue=60, saturation=0.3, brightness=0.0, kelvin=3500)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_off)
+
+        # Downlight is on with specific colors
+        downlight_colors = [
+            HSBK(hue=240, saturation=1.0, brightness=0.9, kelvin=3500)
+        ] * 16
+        ceiling_176.get_downlight_colors = AsyncMock(return_value=downlight_colors)
+
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(False)
+            mock_parent.assert_called_once_with(False, 0.0)
+
+        # Both should be stored (regardless of brightness)
+        assert ceiling_176._stored_uplight_state == uplight_off
+        assert ceiling_176._stored_downlight_state == downlight_colors
+
+    async def test_set_power_off_captures_both_components(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power(False) captures both components when both are on."""
+        uplight_color = HSBK(hue=60, saturation=0.5, brightness=1.0, kelvin=5000)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+
+        downlight_colors = [
+            HSBK(hue=180, saturation=0.7, brightness=0.8, kelvin=4000)
+        ] * 16
+        ceiling_176.get_downlight_colors = AsyncMock(return_value=downlight_colors)
+
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(False)
+            mock_parent.assert_called_once_with(False, 0.0)
+
+        # Both should be stored
+        assert ceiling_176._stored_uplight_state == uplight_color
+        assert ceiling_176._stored_downlight_state == downlight_colors
+
+    async def test_set_power_off_with_duration(self, ceiling_176: CeilingLight) -> None:
+        """Test set_power(False) passes duration to parent."""
+        uplight_color = HSBK(hue=0, saturation=0, brightness=0.5, kelvin=3500)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+        ceiling_176.get_downlight_colors = AsyncMock(
+            return_value=[HSBK(hue=0, saturation=0, brightness=0.0, kelvin=3500)] * 16
+        )
+
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(False, duration=2.5)
+            mock_parent.assert_called_once_with(False, 2.5)
+
+    async def test_set_power_on_does_not_capture(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power(True) does NOT capture colors (only off captures)."""
+        # Pre-set stored states
+        ceiling_176._stored_uplight_state = HSBK(
+            hue=100, saturation=0.5, brightness=0.5, kelvin=3500
+        )
+        ceiling_176._stored_downlight_state = [
+            HSBK(hue=200, saturation=0.5, brightness=0.5, kelvin=3500)
+        ] * 16
+
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(True)
+            mock_parent.assert_called_once_with(True, 0.0)
+
+        # get_uplight_color and get_downlight_colors should NOT be called
+        # (they weren't mocked, so they would fail if called)
+
+        # Stored states should remain unchanged
+        assert ceiling_176._stored_uplight_state.hue == 100
+        assert ceiling_176._stored_downlight_state[0].hue == 200
+
+    async def test_set_power_with_integer_off(self, ceiling_176: CeilingLight) -> None:
+        """Test set_power(0) captures colors (integer form)."""
+        uplight_color = HSBK(hue=300, saturation=0.9, brightness=0.6, kelvin=3000)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+
+        downlight_colors = [
+            HSBK(hue=180, saturation=0.5, brightness=0.0, kelvin=3500)
+        ] * 16
+        ceiling_176.get_downlight_colors = AsyncMock(return_value=downlight_colors)
+
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(0)
+            mock_parent.assert_called_once_with(0, 0.0)
+
+        # Both should be stored regardless of brightness
+        assert ceiling_176._stored_uplight_state == uplight_color
+        assert ceiling_176._stored_downlight_state == downlight_colors
+
+    async def test_set_power_with_integer_on(self, ceiling_176: CeilingLight) -> None:
+        """Test set_power(65535) does not capture colors (integer form)."""
+        with patch.object(
+            MatrixLight, "set_power", new_callable=AsyncMock
+        ) as mock_parent:
+            await ceiling_176.set_power(65535)
+            mock_parent.assert_called_once_with(65535, 0.0)
+
+    async def test_set_power_invalid_integer_raises(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power with invalid integer raises ValueError."""
+        with pytest.raises(ValueError, match="Power level must be 0 or 65535"):
+            await ceiling_176.set_power(100)
+
+    async def test_set_power_invalid_type_raises(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power with invalid type raises TypeError."""
+        with pytest.raises(TypeError, match="Expected bool or int"):
+            await ceiling_176.set_power("on")  # type: ignore[arg-type]
+
+    async def test_set_power_off_persists_state_to_file(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power(False) saves state to file when state_file is set."""
+        ceiling_176._state_file = "/tmp/test_state.json"
+
+        uplight_color = HSBK(hue=45, saturation=0.3, brightness=0.7, kelvin=4500)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+        ceiling_176.get_downlight_colors = AsyncMock(
+            return_value=[HSBK(hue=0, saturation=0, brightness=0.0, kelvin=3500)] * 16
+        )
+
+        with patch.object(MatrixLight, "set_power", new_callable=AsyncMock):
+            await ceiling_176.set_power(False)
+
+        ceiling_176._save_state_to_file.assert_called_once()
+
+    async def test_set_power_off_no_persist_without_state_file(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test set_power(False) doesn't save state when state_file is None."""
+        ceiling_176._state_file = None
+        ceiling_176._save_state_to_file.reset_mock()
+
+        uplight_color = HSBK(hue=45, saturation=0.3, brightness=0.7, kelvin=4500)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+        ceiling_176.get_downlight_colors = AsyncMock(
+            return_value=[HSBK(hue=0, saturation=0, brightness=0.0, kelvin=3500)] * 16
+        )
+
+        with patch.object(MatrixLight, "set_power", new_callable=AsyncMock):
+            await ceiling_176.set_power(False)
+
+        ceiling_176._save_state_to_file.assert_not_called()
+
+    async def test_set_power_workflow_off_then_turn_on_uplight(
+        self, ceiling_176: CeilingLight
+    ) -> None:
+        """Test workflow: set_power(off) -> turn_uplight_on() restores color."""
+        # Initial uplight color before turning off
+        uplight_color = HSBK(hue=120, saturation=0.8, brightness=0.75, kelvin=4000)
+        ceiling_176.get_uplight_color = AsyncMock(return_value=uplight_color)
+        ceiling_176.get_downlight_colors = AsyncMock(
+            return_value=[HSBK(hue=0, saturation=0, brightness=0.0, kelvin=3500)] * 16
+        )
+
+        # Turn off entire light
+        with patch.object(MatrixLight, "set_power", new_callable=AsyncMock):
+            await ceiling_176.set_power(False)
+
+        # Verify uplight was stored
+        assert ceiling_176._stored_uplight_state == uplight_color
+
+        # Now _determine_uplight_brightness should return stored color
+        # (simulate what turn_uplight_on() would do)
+        assert ceiling_176._stored_uplight_state.brightness > 0

{lifx_async-4.7.2 → lifx_async-4.7.3}/tests/test_effects/test_integration.py

@@ -1,6 +1,7 @@
 """Integration tests for effects system."""
 
 import asyncio
+import time
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
@@ -9,6 +10,56 @@ from lifx.color import HSBK
 from lifx.effects import Conductor, EffectColorloop, EffectPulse
 
 
+async def wait_for_mock_called(
+    mock: MagicMock, timeout: float = 1.0, poll_interval: float = 0.01
+) -> None:
+    """Wait for a mock to be called, with timeout.
+
+    This is more reliable than fixed sleeps on slow CI systems (especially Windows).
+
+    Args:
+        mock: The mock object to check
+        timeout: Maximum time to wait in seconds
+        poll_interval: Time between checks in seconds
+
+    Raises:
+        AssertionError: If mock was not called within timeout
+    """
+    start = time.monotonic()
+    while time.monotonic() - start < timeout:
+        if mock.call_count > 0:
+            return
+        await asyncio.sleep(poll_interval)
+    raise AssertionError(f"Expected mock to be called within {timeout}s")
+
+
+async def wait_for_effect_complete(
+    conductor: Conductor,
+    light: MagicMock,
+    timeout: float = 2.0,
+    poll_interval: float = 0.05,
+) -> None:
+    """Wait for an effect to complete and be removed from registry.
+
+    This is more reliable than fixed sleeps on slow CI systems (especially Windows).
+
+    Args:
+        conductor: The Conductor instance
+        light: The light to check
+        timeout: Maximum time to wait in seconds
+        poll_interval: Time between checks in seconds
+
+    Raises:
+        AssertionError: If effect was not removed within timeout
+    """
+    start = time.monotonic()
+    while time.monotonic() - start < timeout:
+        if conductor.effect(light) is None:
+            return
+        await asyncio.sleep(poll_interval)
+    raise AssertionError(f"Expected effect to complete within {timeout}s")
+
+
 @pytest.fixture
 def conductor():
     """Create a Conductor instance."""
@@ -114,10 +165,9 @@ async def test_pulse_effect_strobe_mode(conductor, mock_light):
     effect = EffectPulse(mode="strobe", cycles=2, period=0.05)
 
     await conductor.start(effect, [mock_light])
-    await asyncio.sleep(0.02)
 
-    # Verify waveform called
-    mock_light.set_waveform.assert_called()
+    # Use polling instead of fixed sleep - more reliable on slow CI systems
+    await wait_for_mock_called(mock_light.set_waveform, timeout=1.0)
 
     await conductor.stop([mock_light])
 
@@ -306,12 +356,9 @@ async def test_effect_completion_restores_state(conductor, mock_light):
 
     await conductor.start(effect, [mock_light])
 
-    # Wait for effect to complete (period * cycles + buffer)
-    # Give extra time for effect completion and cleanup
-    await asyncio.sleep(0.5)
-
-    # Effect should have completed and been removed from running registry
-    assert conductor.effect(mock_light) is None
+    # Use polling instead of fixed sleep - more reliable on slow CI systems
+    # The effect should complete within ~0.1s but we allow up to 2s for CI variability
+    await wait_for_effect_complete(conductor, mock_light, timeout=2.0)
 
 
 @pytest.mark.asyncio

{lifx_async-4.7.2 → lifx_async-4.7.3}/tests/test_network/test_connection.py

@@ -169,8 +169,10 @@ class TestDeviceConnection:
 
             # If truly concurrent, total time should be ~0.1s (one sleep duration)
             # If serialized, it would be ~0.2s (two sleep durations)
-            # Allow some overhead, but verify concurrency
-            assert total_time < 0.15, (
+            # Use generous tolerance (0.19s) to account for CI variability
+            # (especially on macOS where timing can be less precise under load)
+            # Anything under 0.2s proves concurrency since serial would be >= 0.2s
+            assert total_time < 0.19, (
                 f"Requests took too long ({total_time}s), suggesting serialization"
             )
 

{lifx_async-4.7.2 → lifx_async-4.7.3}/tests/test_theme/test_canvas.py

@@ -122,9 +122,11 @@ class TestShufflePoints:
     def test_shuffle_preserves_point_count(self) -> None:
         """Test that shuffle_points preserves number of points."""
         canvas = Canvas()
+        # Use points spaced far apart (10 units) to avoid collision after shuffle.
+        # shuffle_point() moves each point by ±3, so points 7+ apart can't collide.
         canvas[(0, 0)] = Colors.RED
-        canvas[(5, 5)] = Colors.GREEN
-        canvas[(10, 10)] = Colors.BLUE
+        canvas[(10, 10)] = Colors.GREEN
+        canvas[(20, 20)] = Colors.BLUE
 
         original_count = len(canvas.points)
         canvas.shuffle_points()

{lifx_async-4.7.2 → lifx_async-4.7.3}/uv.lock

@@ -337,7 +337,7 @@ wheels = [
 
 [[package]]
 name = "lifx-async"
-version = "4.7.2"
+version = "4.7.3"
 source = { editable = "." }
 
 [package.dev-dependencies]