lifx-async 4.4.0__tar.gz → 4.4.1__tar.gz

{lifx_async-4.4.0 → lifx_async-4.4.1}/PKG-INFO

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

@@ -2,6 +2,14 @@
 
 <!-- version list -->
 
+## v4.4.1 (2025-12-03)
+
+### Bug Fixes
+
+- **theme**: Prevent color displacement in multi-tile matrix theme application
+  ([`ca936ec`](https://github.com/Djelibeybi/lifx-async/commit/ca936ec8df84fc42803182ae9898d243e017c5a3))
+
+
 ## v4.4.0 (2025-11-29)
 
 ### Features

{lifx_async-4.4.0 → lifx_async-4.4.1}/examples/12_matrix_effects.py

@@ -7,7 +7,7 @@ import argparse
 import asyncio
 
 from lifx import HSBK, Colors, MatrixLight
-from lifx.protocol.protocol_types import TileEffectSkyType, TileEffectType
+from lifx.protocol.protocol_types import FirmwareEffect, TileEffectSkyType
 
 
 async def main(ip: str):
@@ -26,9 +26,9 @@ async def main(ip: str):
 
         # Get current effect state
         print("Getting current effect state...")
-        current_effect = await matrix.get_tile_effect()
+        current_effect = await matrix.get_effect()
         print(f"Current effect: {current_effect.effect_type}")
-        if current_effect.effect_type != TileEffectType.OFF:
+        if current_effect.effect_type != FirmwareEffect.OFF:
             print(f"  Speed: {current_effect.speed}")
             print(f"  Duration: {current_effect.duration}s")
             if current_effect.palette:
@@ -38,8 +38,8 @@ async def main(ip: str):
         # Demonstrate MORPH effect
         print("Starting MORPH effect...")
         print("  (smooth color transitions across tiles)")
-        await matrix.set_tile_effect(
-            effect_type=TileEffectType.MORPH,
+        await matrix.set_effect(
+            effect_type=FirmwareEffect.MORPH,
             speed=5,
             palette=[Colors.RED, Colors.BLUE, Colors.GREEN, Colors.PURPLE],
         )
@@ -49,8 +49,8 @@ async def main(ip: str):
         # Demonstrate FLAME effect
         print("\nStarting FLAME effect...")
         print("  (flickering fire animation)")
-        await matrix.set_tile_effect(
-            effect_type=TileEffectType.FLAME,
+        await matrix.set_effect(
+            effect_type=FirmwareEffect.FLAME,
             speed=3,
             palette=[Colors.ORANGE, Colors.RED, Colors.YELLOW],
         )
@@ -60,8 +60,8 @@ async def main(ip: str):
         # Demonstrate SKY effect with SUNRISE
         print("\nStarting SKY effect with SUNRISE...")
         print("  (sunrise color progression)")
-        await matrix.set_tile_effect(
-            effect_type=TileEffectType.SKY,
+        await matrix.set_effect(
+            effect_type=FirmwareEffect.SKY,
             speed=10,
             sky_type=TileEffectSkyType.SUNRISE,
         )
@@ -71,8 +71,8 @@ async def main(ip: str):
         # Demonstrate SKY effect with CLOUDS
         print("\nStarting SKY effect with CLOUDS...")
         print("  (moving cloud patterns)")
-        await matrix.set_tile_effect(
-            effect_type=TileEffectType.SKY,
+        await matrix.set_effect(
+            effect_type=FirmwareEffect.SKY,
             speed=5,
             sky_type=TileEffectSkyType.CLOUDS,
             cloud_saturation_min=50,
@@ -86,11 +86,11 @@ async def main(ip: str):
         ocean_palette = [
             Colors.CYAN,
             Colors.BLUE,
-            HSBK(hue=210.0, saturation=1.0, brightness=0.4, kelvin=3500),  # deep blue
+            HSBK(hue=210, saturation=1.0, brightness=0.4, kelvin=3500),  # deep blue
             HSBK(36408, 65535, 38550, 3500),  # Ocean blue
         ]
-        await matrix.set_tile_effect(
-            effect_type=TileEffectType.MORPH,
+        await matrix.set_effect(
+            effect_type=FirmwareEffect.MORPH,
             speed=3,
             palette=ocean_palette,
         )
@@ -99,11 +99,11 @@ async def main(ip: str):
 
         # Stop effect and restore
         print("\nStopping effect...")
-        await matrix.set_tile_effect(effect_type=TileEffectType.OFF)
+        await matrix.set_effect(effect_type=FirmwareEffect.OFF)
         await asyncio.sleep(1)
 
         # Verify effect stopped
-        final_effect = await matrix.get_tile_effect()
+        final_effect = await matrix.get_effect()
         print(f"Final effect state: {final_effect.effect_type}")
 
         if power == 0:

{lifx_async-4.4.0 → lifx_async-4.4.1}/pyproject.toml

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

{lifx_async-4.4.0 → lifx_async-4.4.1}/src/lifx/devices/matrix.py

@@ -14,7 +14,6 @@ Terminology:
 
 from __future__ import annotations
 
-import asyncio
 import logging
 import time
 from dataclasses import asdict, dataclass
@@ -544,6 +543,57 @@ class MatrixLight(Light):
 
         return result
 
+    async def get_all_tile_colors(self) -> list[list[HSBK]]:
+        """Get colors for all tiles in the chain.
+
+        Fetches colors from each tile in the device chain and returns them
+        as a list of color lists (one per tile). This is the matrix equivalent
+        of MultiZoneLight's get_all_color_zones().
+
+        Always fetches from device. Tiles are queried sequentially to avoid
+        overwhelming the device with concurrent requests.
+
+        Returns:
+            List of color lists, one per tile. Each inner list contains
+            the colors for that tile (typically 64 for 8x8 tiles).
+
+        Raises:
+            LifxDeviceNotFoundError: If device is not connected
+            LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
+
+        Example:
+            ```python
+            # Get colors for all tiles
+            all_colors = await matrix.get_all_tile_colors()
+            print(f"Device has {len(all_colors)} tiles")
+            for i, tile_colors in enumerate(all_colors):
+                print(f"Tile {i}: {len(tile_colors)} colors")
+
+            # Flatten to single list if needed
+            flat_colors = [c for tile in all_colors for c in tile]
+            ```
+        """
+        # Get device chain (use cached if available)
+        if self._device_chain is None:
+            device_chain = await self.get_device_chain()
+        else:
+            device_chain = self._device_chain
+
+        # Fetch colors from each tile sequentially
+        all_colors: list[list[HSBK]] = []
+        for tile in device_chain:
+            tile_colors = await self.get64(tile_index=tile.tile_index)
+            all_colors.append(tile_colors)
+
+        # Update state if it exists (flatten for state storage)
+        if self._state is not None and hasattr(self._state, "tile_colors"):
+            flat_colors = [c for tile_colors in all_colors for c in tile_colors]
+            self._state.tile_colors = flat_colors
+            self._state.last_updated = time.time()
+
+        return all_colors
+
     async def set64(
         self,
         tile_index: int,
@@ -993,8 +1043,13 @@ class MatrixLight(Light):
         canvas = Canvas()
         for tile in tiles:
             canvas.add_points_for_tile((int(tile.user_x), int(tile.user_y)), theme)
-            canvas.shuffle_points()
-            canvas.blur_by_distance()
+
+        # Shuffle and blur ONCE after all points are added
+        # (Previously these were inside the loop, causing earlier tiles' points
+        # to be shuffled/blurred multiple times, displacing them from their
+        # intended positions and losing theme color variety)
+        canvas.shuffle_points()
+        canvas.blur_by_distance()
 
         # Create tile canvas and fill in gaps for smooth interpolation
         tile_canvas = Canvas()
@@ -1068,7 +1123,7 @@ class MatrixLight(Light):
     async def refresh_state(self) -> None:
         """Refresh matrix light state from hardware.
 
-        Fetches color, tiles, tile colors, and effect.
+        Fetches color, tiles, tile colors for all tiles, and effect.
 
         Raises:
             RuntimeError: If state has not been initialized
@@ -1077,15 +1132,12 @@ class MatrixLight(Light):
         """
         await super().refresh_state()
 
-        # Fetch all matrix light state
-        async with asyncio.TaskGroup() as tg:
-            colors_task = tg.create_task(self.get64())
-            effect_task = tg.create_task(self.get_effect())
-
-        tile_colors = colors_task.result()
-        effect = effect_task.result()
+        # Fetch all matrix light state sequentially to avoid overwhelming device
+        all_tile_colors = await self.get_all_tile_colors()
+        effect = await self.get_effect()
 
-        self._state.tile_colors = tile_colors
+        # Flatten tile colors for state storage
+        self._state.tile_colors = [c for tile in all_tile_colors for c in tile]
         self._state.effect = effect.effect_type
 
     async def _initialize_state(self) -> MatrixLightState:
@@ -1103,24 +1155,24 @@ class MatrixLight(Light):
         """
         light_state = await super()._initialize_state()
 
-        async with asyncio.TaskGroup() as tg:
-            chain_task = tg.create_task(self.get_device_chain())
-            tile_colors_task = tg.create_task(self.get64())
-            effect_task = tg.create_task(self.get_effect())
-
-        chain = chain_task.result()
+        # Fetch matrix-specific state sequentially to avoid overwhelming device
+        chain = await self.get_device_chain()
         tile_orientations = {
             index: tile.nearest_orientation for index, tile in enumerate(chain)
         }
-        tile_colors = tile_colors_task.result()
-        effect = effect_task.result()
+        # get_all_tile_colors uses cached chain from above
+        all_tile_colors = await self.get_all_tile_colors()
+        effect = await self.get_effect()
+
+        # Flatten tile colors for state storage
+        flat_tile_colors = [c for tile in all_tile_colors for c in tile]
 
         # Create state instance with matrix fields
         self._state = MatrixLightState.from_light_state(
             light_state,
             chain=chain,
             tile_orientations=tile_orientations,
-            tile_colors=tile_colors,
+            tile_colors=flat_tile_colors,
             effect=effect.effect_type,
         )
 

{lifx_async-4.4.0 → lifx_async-4.4.1}/src/lifx/theme/generators.py

@@ -165,10 +165,16 @@ class MatrixGenerator:
         shuffled_theme = theme.shuffled()
         shuffled_theme.ensure_color()
 
+        # Add points for all tiles first
         for (left_x, top_y), (width, height) in self.coords_and_sizes:
             canvas.add_points_for_tile((left_x, top_y), shuffled_theme)
-            canvas.shuffle_points()
-            canvas.blur_by_distance()
+
+        # Shuffle and blur ONCE after all points are added
+        # (Previously these were inside the loop, causing earlier tiles' points
+        # to be shuffled/blurred multiple times, displacing them from their
+        # intended positions and losing theme color variety)
+        canvas.shuffle_points()
+        canvas.blur_by_distance()
 
         # Create tile canvas and fill gaps
         tile_canvas = Canvas()

{lifx_async-4.4.0 → lifx_async-4.4.1}/tests/test_devices/test_state_matrix.py

@@ -152,6 +152,35 @@ class TestMatrixLightStateManagement:
             retrieved = await matrix_light.get64(tile_index=0)
             assert len(retrieved) == 64
 
+    @pytest.mark.asyncio
+    async def test_get_all_tile_colors_fetches_all_tiles(
+        self, emulator_devices
+    ) -> None:
+        """Test get_all_tile_colors() fetches colors from all tiles in chain."""
+        template: MatrixLight = emulator_devices[6]  # d073d5000007
+
+        async with await MatrixLight.connect(
+            serial=template.serial, ip=template.ip, port=template.port
+        ) as matrix_light:
+            assert isinstance(matrix_light, MatrixLight)
+
+            # Get colors for all tiles
+            all_colors = await matrix_light.get_all_tile_colors()
+
+            # Should return a list of color lists (one per tile)
+            assert isinstance(all_colors, list)
+            assert len(all_colors) == matrix_light.tile_count
+
+            # Each tile should have the correct number of colors
+            for tile_colors in all_colors:
+                assert isinstance(tile_colors, list)
+                assert len(tile_colors) == 64  # 8x8 tile
+                assert all(isinstance(c, HSBK) for c in tile_colors)
+
+            # State should be updated with flattened colors
+            expected_total = matrix_light.tile_count * 64
+            assert len(matrix_light.state.tile_colors) == expected_total
+
     @pytest.mark.asyncio
     async def test_get_effect_updates_state(self, emulator_devices) -> None:
         """Test get_effect() updates state when it exists."""

{lifx_async-4.4.0 → lifx_async-4.4.1}/tests/test_theme/test_generators.py

@@ -172,3 +172,103 @@ class TestMatrixGenerator:
 
         assert len(tiles) == 1
         assert len(tiles[0]) == 256
+
+    def test_multiple_tiles_use_all_theme_colors(self) -> None:
+        """Test that multiple tiles use colors from the entire theme, not just the last.
+
+        Regression test for bug where shuffle_points() and blur_by_distance() were
+        called inside the tile loop, causing points from earlier tiles to be displaced
+        multiple times, resulting in only the last tile's colors being visible.
+        """
+        import random
+
+        # Use fixed seed for reproducibility
+        random.seed(42)
+
+        # Create a 5-tile chain (like a real LIFX Tile setup)
+        coords_and_sizes = [
+            ((0, 0), (8, 8)),
+            ((8, 0), (8, 8)),
+            ((16, 0), (8, 8)),
+            ((24, 0), (8, 8)),
+            ((32, 0), (8, 8)),
+        ]
+        gen = MatrixGenerator(coords_and_sizes)
+
+        # Theme with distinctly different colors (high saturation, different hues)
+        theme = Theme(
+            [Colors.RED, Colors.GREEN, Colors.BLUE, Colors.CYAN, Colors.MAGENTA]
+        )
+
+        tiles = gen.get_theme_colors(theme)
+
+        # Collect unique hue values across all tiles (rounded for float precision)
+        all_hues: set[int] = set()
+        for tile in tiles:
+            for color in tile:
+                # Round hue to nearest 10 degrees to group similar hues
+                rounded_hue = round(color.hue / 10) * 10
+                all_hues.add(rounded_hue)
+
+        # With 5 distinct theme colors, we should see variety across the tiles
+        # If the bug exists, we'd see very few unique hues (colors would converge)
+        # The theme has hues at approximately: 0 (red), 120 (green), 240 (blue),
+        # 180 (cyan), 300 (magenta)
+        # With blending, we expect to see intermediate hues too
+        assert len(all_hues) >= 3, (
+            f"Expected at least 3 distinct hue ranges but got {len(all_hues)}: "
+            f"{sorted(all_hues)}. This suggests colors are converging to a "
+            "single color instead of using the full theme."
+        )
+
+    def test_all_theme_colors_represented_in_output(self) -> None:
+        """Test that all theme colors are represented in the generated output.
+
+        Regression test for bug where shuffle_points() and blur_by_distance() were
+        called inside the tile loop, causing points from earlier tiles to be displaced
+        multiple times. This resulted in only some theme colors appearing in the output.
+        """
+        import random
+
+        from lifx.color import HSBK
+
+        # Use fixed seed for reproducibility
+        random.seed(12345)
+
+        # Create tiles that are far apart spatially
+        coords_and_sizes = [
+            ((0, 0), (8, 8)),
+            ((50, 0), (8, 8)),
+        ]
+        gen = MatrixGenerator(coords_and_sizes)
+
+        # Theme with two distinct, non-wrapping colors (Yellow=60, Cyan=180)
+        # These are 120 degrees apart, so we should see hues spanning that range
+        theme = Theme(
+            [
+                HSBK(hue=60, saturation=1.0, brightness=1.0, kelvin=3500),  # Yellow
+                HSBK(hue=180, saturation=1.0, brightness=1.0, kelvin=3500),  # Cyan
+            ]
+        )
+
+        tiles = gen.get_theme_colors(theme)
+
+        # Collect all hues across all tiles
+        all_hues = [c.hue for tile in tiles for c in tile]
+
+        # With Yellow (60) and Cyan (180), we expect hues to span from ~60 to ~180
+        # If the bug exists, we'd only see hues near one of the colors
+        min_hue = min(all_hues)
+        max_hue = max(all_hues)
+        hue_spread = max_hue - min_hue
+
+        # The spread should be at least 80 degrees (2/3 the distance between colors)
+        # if both theme colors are being represented.
+        # With the bug, we only see ~66 degree spread (62-128), missing cyan.
+        # With the fix, we see spread > 100 degrees as colors approach 60 and 180.
+        assert hue_spread >= 80, (
+            f"Hue spread is only {hue_spread:.1f} degrees "
+            f"(range: {min_hue:.0f}-{max_hue:.0f}). Expected at least 80 degrees "
+            "when theme has Yellow(60) and Cyan(180). "
+            "This suggests only one theme color is being used."
+        )

{lifx_async-4.4.0 → lifx_async-4.4.1}/uv.lock

@@ -343,7 +343,7 @@ wheels = [
 
 [[package]]
 name = "lifx-async"
-version = "4.4.0"
+version = "4.4.1"
 source = { editable = "." }
 
 [package.dev-dependencies]