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

{lifx_async-4.3.1 → lifx_async-4.3.3}/.github/workflows/pr-automation.yml

@@ -71,6 +71,8 @@ jobs:
           docs
           ci
           deps
+          effects
+          themes
         requireScope: false
         subjectPattern: ^(?![A-Z]).+$
         subjectPatternError: |

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

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

@@ -2,6 +2,25 @@
 
 <!-- version list -->
 
+## 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
+
+- **effects**: Add name property to LIFXEffect and subclasses
+  ([`deb8a54`](https://github.com/Djelibeybi/lifx-async/commit/deb8a54f674d2d4cd9b8dce519dc6ca8678e048a))
+
+
 ## v4.3.1 (2025-11-22)
 
 ### Bug Fixes

{lifx_async-4.3.1 → lifx_async-4.3.3}/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.1 → lifx_async-4.3.3}/pyproject.toml

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

{lifx_async-4.3.1 → lifx_async-4.3.3}/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.1 → lifx_async-4.3.3}/src/lifx/effects/base.py

@@ -59,6 +59,16 @@ class LIFXEffect(ABC):
         self.conductor: Conductor | None = None
         self.participants: list[Light] = []
 
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the name of the effect.
+
+        Returns:
+            The effect name as a string
+        """
+        raise NotImplementedError("Subclasses must implement name property")
+
     async def async_perform(self, participants: list[Light]) -> None:
         """Perform common setup and play the effect.
 

{lifx_async-4.3.1 → lifx_async-4.3.3}/src/lifx/effects/colorloop.py

@@ -127,6 +127,15 @@ class EffectColorloop(LIFXEffect):
         self._running = False
         self._stop_event = asyncio.Event()
 
+    @property
+    def name(self) -> str:
+        """Return the name of the effect.
+
+        Returns:
+            The effect name 'colorloop'
+        """
+        return "colorloop"
+
     async def async_play(self) -> None:
         """Execute the colorloop effect continuously."""
         self._running = True

{lifx_async-4.3.1 → lifx_async-4.3.3}/src/lifx/effects/pulse.py

@@ -136,6 +136,15 @@ class EffectPulse(LIFXEffect):
         if self.cycles < 1:
             raise ValueError(f"Cycles must be 1 or higher, got {self.cycles}")
 
+    @property
+    def name(self) -> str:
+        """Return the name of the effect.
+
+        Returns:
+            The effect name 'pulse'
+        """
+        return "pulse"
+
     async def async_play(self) -> None:
         """Execute the pulse effect on all participants."""
         # Determine colors for each light

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import pytest
 
-from lifx.color import HSBK
+from lifx.color import HSBK, Colors
 from lifx.devices.matrix import MatrixEffect, MatrixLight, TileInfo
 from lifx.protocol.protocol_types import FirmwareEffect, TileEffectSkyType
 
@@ -74,23 +74,22 @@ class TestMatrixLight:
             assert matrix.tile_count == len(await matrix.get_device_chain())
 
     async def test_get64_single_tile(self, emulator_devices) -> None:
-        """Test getting colors from 8x8 tile (64 zones)."""
+        """Test getting colors from 8x8 tile (64 zones) with default parameters."""
         matrix = emulator_devices[6]
         async with matrix:
             chain = await matrix.get_device_chain()
             tile = chain[0]
 
-            # Get colors from first tile
-            colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-            )
+            # Verify tile dimensions
+            assert tile.width == 8
+            assert tile.height == 8
+            assert tile.total_zones == 64
+
+            # Get colors using default parameters (no args needed)
+            colors = await matrix.get64()
 
             assert isinstance(colors, list)
-            assert len(colors) > 0
+            assert len(colors) == 64  # Returns actual number of zones
             assert all(isinstance(color, HSBK) for color in colors)
 
     async def test_set64_single_tile(self, emulator_devices) -> None:
@@ -102,7 +101,7 @@ class TestMatrixLight:
 
             # Set all zones to red
             zone_count = tile.width * tile.height
-            red_colors = [HSBK.from_rgb(255, 0, 0)] * min(zone_count, 64)
+            red_colors = [Colors.RED] * min(zone_count, 64)
 
             await matrix.set64(
                 tile_index=0,
@@ -115,13 +114,7 @@ class TestMatrixLight:
             )
 
             # Verify colors were set (read back)
-            colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-            )
+            colors = await matrix.get64()
 
             # First color should be red (allow protocol conversion tolerance)
             assert colors[0].hue < 10 or colors[0].hue > 350  # Red ~0 deg
@@ -144,13 +137,7 @@ class TestMatrixLight:
             await matrix.set_matrix_colors(tile_index=0, colors=gradient, duration=0)
 
             # Verify first few colors (partial verification to avoid test complexity)
-            colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-            )
+            colors = await matrix.get64()
             assert len(colors) > 0
 
     async def test_set_matrix_colors_solid_color(self, emulator_devices) -> None:
@@ -167,24 +154,18 @@ class TestMatrixLight:
             tile = chain[0]
 
             # Create solid red across all zones
-            red_colors = [HSBK.from_rgb(255, 0, 0)] * tile.total_zones
+            red_colors = [Colors.RED] * tile.total_zones
 
             # Set all zones to red (should use SetColor packet)
             await matrix.set_matrix_colors(tile_index=0, colors=red_colors, duration=0)
 
             # Verify the color was set by reading back
-            colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-            )
+            colors = await matrix.get64()
 
             # Verify first zone is red
-            assert colors[0].hue < 10 or colors[0].hue > 350
-            assert colors[0].saturation > 0.9
-            assert colors[0].brightness > 0.9
+            assert colors[0].hue == 0
+            assert colors[0].saturation == 1.0
+            assert colors[0].brightness == 1.0
 
     async def test_get_effect(self, emulator_devices) -> None:
         """Test getting current tile effect."""
@@ -217,10 +198,10 @@ class TestMatrixLight:
         async with matrix:
             # Create rainbow palette
             rainbow = [
-                HSBK(0, 1.0, 1.0, 3500),  # Red
-                HSBK(60, 1.0, 1.0, 3500),  # Yellow
-                HSBK(120, 1.0, 1.0, 3500),  # Green
-                HSBK(240, 1.0, 1.0, 3500),  # Blue
+                Colors.RED,  # Red
+                Colors.YELLOW,  # Yellow
+                Colors.GREEN,  # Green
+                Colors.BLUE,  # Blue
             ]
 
             await matrix.set_effect(
@@ -240,10 +221,10 @@ class TestMatrixLight:
         async with matrix:
             # Flame effect with fire colors
             fire_palette = [
-                HSBK.from_rgb(255, 0, 0),  # Red
-                HSBK.from_rgb(255, 69, 0),  # Orange-red
-                HSBK.from_rgb(255, 140, 0),  # Orange
-                HSBK.from_rgb(255, 215, 0),  # Gold
+                Colors.RED,  # Red
+                HSBK(hue=16, saturation=1.0, brightness=1.0, kelvin=3500),
+                Colors.ORANGE,  # Orange
+                HSBK(hue=51, saturation=1.0, brightness=1.0, kelvin=3500),
             ]
 
             await matrix.set_effect(
@@ -341,11 +322,11 @@ class TestMatrixLight:
             assert effect.effect_type == FirmwareEffect.OFF
 
     async def test_get64_large_tile(self, ceiling_device) -> None:
-        """Test getting colors from 16x8 tile (128 zones).
+        """Test getting colors from 16x8 tile (128 zones) with default parameters.
 
-        Ceiling devices have 16x8 tiles with 128 zones, which is larger than
-        the 64-zone limit for direct get64 operations. This tests the protocol
-        can handle reading from tiles with >64 zones.
+        Ceiling devices have 16x8 tiles with 128 zones. The get64() method returns
+        up to 64 colors due to protocol limitations, so we have to send two get64
+        requests.
         """
         matrix = ceiling_device
         async with matrix:
@@ -357,17 +338,13 @@ class TestMatrixLight:
             assert tile.height == 8
             assert tile.total_zones == 128
 
-            # Get first 64 zones from the large tile
-            colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-            )
+            # Get zones using two get64 requests, 64 zones per request.
+            colors: list[HSBK] = []
+            colors.extend(await matrix.get64())
+            colors.extend(await matrix.get64(y=4))
 
             assert isinstance(colors, list)
-            assert len(colors) == 64  # get64 returns max 64 colors
+            assert len(colors) == 128
             assert all(isinstance(color, HSBK) for color in colors)
 
     async def test_set64_large_tile(self, ceiling_device) -> None:
@@ -385,9 +362,12 @@ class TestMatrixLight:
             assert tile.total_zones == 128
 
             # Create 64 blue colors for first 64 zones
-            blue_colors = [HSBK.from_rgb(0, 0, 255)] * 64
+            blue_colors = [Colors.BLUE] * 64
+
+            # Create 64 red colors for the second 64 zones
+            red_colors = [Colors.RED] * 64
 
-            # Set first 64 zones to blue (writes to frame buffer 1)
+            # Set first 64 zones to blue (on frame buffer 1)
             await matrix.set64(
                 tile_index=0,
                 length=1,
@@ -399,32 +379,39 @@ class TestMatrixLight:
                 fb_index=1,  # Write to temp buffer
             )
 
-            # Copy frame buffer 1 to frame buffer 0 (display)
-            await matrix.copy_frame_buffer(tile_index=0, source_fb=1, target_fb=0)
-
-            # Read back the first 64 zones from display buffer
-            colors = await matrix.get64(
+            # Set the second 64 zones to red (on frame buffer 1)
+            await matrix.set64(
                 tile_index=0,
                 length=1,
                 x=0,
-                y=0,
+                y=4,
                 width=tile.width,
-                fb_index=0,  # Read from display buffer
+                duration=0,
+                colors=red_colors,
+                fb_index=1,  # Write to temp buffer
             )
 
+            # Copy frame buffer 1 to frame buffer 0 (display)
+            await matrix.copy_frame_buffer(tile_index=0, source_fb=1, target_fb=0)
+
+            # Get the updated colors
+            colors: list[HSBK] = []
+            colors.extend(await matrix.get64())
+            colors.extend(await matrix.get64(y=4))
+
             # Verify the colors were set correctly
-            assert len(colors) == 64
+            assert len(colors) == 128
             # Blue is hue ~240
             assert 230 < colors[0].hue < 250
             assert colors[0].saturation > 0.9  # High saturation
             assert colors[0].brightness > 0.9  # Full brightness
-
-            # Note: We can't easily verify this without copying to display buffer
-            # since get64 reads from display buffer (fb_index=0)
-            # This test verifies the operation completes without error
+            # Red is hue ~0
+            assert colors[64].hue == 0
+            assert colors[64].saturation == 1.0
+            assert colors[64].brightness == 1.0
 
     async def test_set_matrix_colors_large_tile(self, ceiling_device) -> None:
-        """Test setting all colors on 16x8 tile (128 zones) using frame buffer strategy.
+        """Test setting all colors on 16x8 tile (128 zones) set_matrix_colors()
 
         This tests the automatic frame buffer strategy for tiles with >64 zones.
         The method should automatically batch the colors and use the frame buffer.
@@ -439,7 +426,7 @@ class TestMatrixLight:
             assert tile.total_zones == 128
 
             # Create a gradient (different colors, so uses set64 not SetColor)
-            colors = [HSBK(i * 360.0 / 128, 1.0, 1.0, 3500) for i in range(128)]
+            colors = [HSBK(round(i * 360.0 / 128), 1.0, 1.0, 3500) for i in range(128)]
 
             # Set all 128 zones at once (should use frame buffer strategy)
             # This requires:
@@ -449,13 +436,7 @@ class TestMatrixLight:
             await matrix.set_matrix_colors(tile_index=0, colors=colors, duration=0)
 
             # Verify first 64 zones
-            first_half = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-            )
+            first_half = await matrix.get64()
 
             assert len(first_half) == 64
             # First zone should be hue 0 (red)
@@ -464,13 +445,7 @@ class TestMatrixLight:
             assert first_half[0].brightness > 0.9  # Full brightness
 
             # Verify second 64 zones
-            second_half = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=4,  # Start at row 4
-                width=tile.width,
-            )
+            second_half = await matrix.get64(y=4)  # Start at row 4
 
             assert len(second_half) == 64
             # Zone 64 should be hue ~180 (cyan)
@@ -508,9 +483,9 @@ class TestMatrixLight:
                 tile_index=0, colors=white_colors, duration=0
             )
 
-            # Create gradient: first 64 zones blue, second 64 zones green
-            blue_colors = [HSBK.from_rgb(0, 0, 255)] * 64
-            green_colors = [HSBK.from_rgb(0, 255, 0)] * 64
+            # Create colors: first 64 zones blue, second 64 zones green
+            blue_colors = [Colors.BLUE] * 64
+            green_colors = [Colors.GREEN] * 64
 
             # Step 1: Set first 64 zones (rows 0-3) to blue in frame buffer 1
             await matrix.set64(
@@ -540,25 +515,11 @@ class TestMatrixLight:
             # This should copy all 128 zones using the tile's width and height
             await matrix.copy_frame_buffer(tile_index=0, source_fb=1, target_fb=0)
 
-            # Step 4: Read back first 64 zones from frame buffer 0 (display)
-            first_64_colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=0,
-                width=tile.width,
-                fb_index=0,  # Read from display buffer
-            )
+            # Step 4: Read back first 64 zones
+            first_64_colors = await matrix.get64()
 
-            # Step 5: Read back second 64 zones from frame buffer 0 (display)
-            second_64_colors = await matrix.get64(
-                tile_index=0,
-                length=1,
-                x=0,
-                y=4,
-                width=tile.width,
-                fb_index=0,  # Read from display buffer
-            )
+            # Step 5: Read back second 64 zones
+            second_64_colors = await matrix.get64(y=4)
 
             # Verify all 128 zones were retrieved
             assert len(first_64_colors) == 64

{lifx_async-4.3.1 → lifx_async-4.3.3}/tests/test_effects/test_base.py

@@ -13,6 +13,11 @@ from lifx.effects.const import DEFAULT_BRIGHTNESS
 class ConcreteEffect(LIFXEffect):
     """Concrete implementation for testing abstract base class."""
 
+    @property
+    def name(self) -> str:
+        """Return the name of the effect."""
+        return "test"
+
     async def async_play(self) -> None:
         """Minimal implementation for testing."""
         pass