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

{lifx_async-4.3.0 → lifx_async-4.3.2}/.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.0 → lifx_async-4.3.2}/PKG-INFO

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

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## 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
+
+- Actually rename the matrix methods
+  ([`061aaa7`](https://github.com/Djelibeybi/lifx-async/commit/061aaa7c1931b2fc606363d5acc14ec7fa1b039b))
+
+
 ## v4.3.0 (2025-11-22)
 
 ### Features

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

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

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

@@ -683,17 +683,17 @@ class MatrixLight(Light):
                 colors=colors,
             )
 
-    async def get_tile_effect(self) -> MatrixEffect:
-        """Get current running tile effect.
+    async def get_effect(self) -> MatrixEffect:
+        """Get current running matrix effect.
 
         Returns:
             MatrixEffect describing the current effect state
 
         Example:
-            >>> effect = await matrix.get_tile_effect()
+            >>> effect = await matrix.get_effect()
             >>> print(f"Effect type: {effect.effect_type}")
         """
-        _LOGGER.debug("Getting tile effect for %s", self.label or self.serial)
+        _LOGGER.debug("Getting matrix effect for %s", self.label or self.serial)
 
         response: packets.Tile.StateEffect = await self.connection.request(
             packets.Tile.GetEffect()
@@ -720,7 +720,7 @@ class MatrixLight(Light):
         self._tile_effect = effect
         return effect
 
-    async def set_tile_effect(
+    async def set_effect(
         self,
         effect_type: FirmwareEffect,
         speed: int = 3000,
@@ -730,7 +730,7 @@ class MatrixLight(Light):
         cloud_saturation_min: int = 0,
         cloud_saturation_max: int = 0,
     ) -> None:
-        """Set tile effect with configuration.
+        """Set matrix effect with configuration.
 
         Args:
             effect_type: Type of effect (OFF, MORPH, FLAME, SKY)
@@ -749,14 +749,14 @@ class MatrixLight(Light):
             ...     HSBK(120, 1.0, 1.0, 3500),  # Green
             ...     HSBK(240, 1.0, 1.0, 3500),  # Blue
             ... ]
-            >>> await matrix.set_tile_effect(
+            >>> await matrix.set_effect(
             ...     effect_type=FirmwareEffect.MORPH,
             ...     speed=5000,
             ...     palette=rainbow,
             ... )
         """
         _LOGGER.debug(
-            "Setting tile effect %s (speed=%d) for %s",
+            "Setting matrix effect %s (speed=%d) for %s",
             effect_type,
             speed,
             self.label or self.serial,

{lifx_async-4.3.0 → lifx_async-4.3.2}/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.0 → lifx_async-4.3.2}/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.0 → lifx_async-4.3.2}/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.0 → lifx_async-4.3.2}/tests/test_devices/test_matrix.py

@@ -186,11 +186,11 @@ class TestMatrixLight:
             assert colors[0].saturation > 0.9
             assert colors[0].brightness > 0.9
 
-    async def test_get_tile_effect(self, emulator_devices) -> None:
+    async def test_get_effect(self, emulator_devices) -> None:
         """Test getting current tile effect."""
         matrix = emulator_devices[6]
         async with matrix:
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
 
             assert isinstance(effect, MatrixEffect)
             assert isinstance(effect.effect_type, FirmwareEffect)
@@ -204,14 +204,14 @@ class TestMatrixLight:
         matrix = emulator_devices[6]
         async with matrix:
             # Fetch tile effect
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
 
             # Should be cached in property
             assert matrix.tile_effect is not None
             assert isinstance(matrix.tile_effect, MatrixEffect)
             assert matrix.tile_effect == effect
 
-    async def test_set_tile_effect_morph(self, emulator_devices) -> None:
+    async def test_set_effect_morph(self, emulator_devices) -> None:
         """Test setting MORPH effect."""
         matrix = emulator_devices[6]
         async with matrix:
@@ -223,18 +223,18 @@ class TestMatrixLight:
                 HSBK(240, 1.0, 1.0, 3500),  # Blue
             ]
 
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.MORPH,
                 speed=5000,
                 palette=rainbow,
             )
 
             # Verify effect was set
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.MORPH
             assert len(effect.palette) == 4
 
-    async def test_set_tile_effect_flame(self, emulator_devices) -> None:
+    async def test_set_effect_flame(self, emulator_devices) -> None:
         """Test setting FLAME effect."""
         matrix = emulator_devices[6]
         async with matrix:
@@ -246,17 +246,17 @@ class TestMatrixLight:
                 HSBK.from_rgb(255, 215, 0),  # Gold
             ]
 
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.FLAME,
                 speed=3000,
                 palette=fire_palette,
             )
 
             # Verify effect was set
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.FLAME
 
-    async def test_set_tile_effect_sky_sunrise(self, ceiling_device) -> None:
+    async def test_set_effect_sky_sunrise(self, ceiling_device) -> None:
         """Test setting SKY effect with SUNRISE.
 
         SKY effects are only supported on LIFX Ceiling devices
@@ -265,18 +265,18 @@ class TestMatrixLight:
         """
         matrix = ceiling_device
         async with matrix:
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.SKY,
                 speed=2000,
                 sky_type=TileEffectSkyType.SUNRISE,
             )
 
             # Verify effect was set
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.SKY
             assert effect.sky_type == TileEffectSkyType.SUNRISE
 
-    async def test_set_tile_effect_sky_sunset(self, ceiling_device) -> None:
+    async def test_set_effect_sky_sunset(self, ceiling_device) -> None:
         """Test setting SKY effect with SUNSET.
 
         SKY effects are only supported on LIFX Ceiling devices
@@ -285,18 +285,18 @@ class TestMatrixLight:
         """
         matrix = ceiling_device
         async with matrix:
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.SKY,
                 speed=2000,
                 sky_type=TileEffectSkyType.SUNSET,
             )
 
             # Verify effect was set
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.SKY
             assert effect.sky_type == TileEffectSkyType.SUNSET
 
-    async def test_set_tile_effect_sky_clouds(self, ceiling_device) -> None:
+    async def test_set_effect_sky_clouds(self, ceiling_device) -> None:
         """Test setting SKY effect with CLOUDS and saturation parameters.
 
         SKY effects are only supported on LIFX Ceiling devices
@@ -305,7 +305,7 @@ class TestMatrixLight:
         """
         matrix = ceiling_device
         async with matrix:
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.SKY,
                 speed=4000,
                 sky_type=TileEffectSkyType.CLOUDS,
@@ -314,30 +314,30 @@ class TestMatrixLight:
             )
 
             # Verify effect was set
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.SKY
             assert effect.sky_type == TileEffectSkyType.CLOUDS
             assert effect.cloud_saturation_min == 50
             assert effect.cloud_saturation_max == 200
 
-    async def test_set_tile_effect_off(self, emulator_devices) -> None:
+    async def test_set_effect_off(self, emulator_devices) -> None:
         """Test turning off tile effect."""
         matrix = emulator_devices[6]
         async with matrix:
             # First set an effect
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.MORPH,
                 speed=3000,
             )
 
             # Then turn it off
-            await matrix.set_tile_effect(
+            await matrix.set_effect(
                 effect_type=FirmwareEffect.OFF,
                 speed=0,
             )
 
             # Verify effect was turned off
-            effect = await matrix.get_tile_effect()
+            effect = await matrix.get_effect()
             assert effect.effect_type == FirmwareEffect.OFF
 
     async def test_get64_large_tile(self, ceiling_device) -> None:

{lifx_async-4.3.0 → lifx_async-4.3.2}/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

{lifx_async-4.3.0 → lifx_async-4.3.2}/tests/test_effects/test_colorloop.py

@@ -14,6 +14,7 @@ def test_colorloop_default_parameters():
     """Test EffectColorloop with default parameters."""
     effect = EffectColorloop()
 
+    assert effect.name == "colorloop"
     assert effect.period == 60
     assert effect.change == 20
     assert effect.spread == 30

{lifx_async-4.3.0 → lifx_async-4.3.2}/tests/test_effects/test_integration.py

@@ -392,6 +392,11 @@ async def test_conductor_exception_during_async_perform():
 
     # Create a custom effect that raises exception during async_perform
     class FailingEffect(LIFXEffect):
+        @property
+        def name(self) -> str:
+            """Return the name of the effect."""
+            return "failing"
+
         async def async_play(self):
             raise RuntimeError("Effect failed during execution")
 

{lifx_async-4.3.0 → lifx_async-4.3.2}/tests/test_effects/test_models.py

@@ -10,6 +10,11 @@ from lifx.effects.models import PreState, RunningEffect
 class DummyEffect(LIFXEffect):
     """Dummy effect for testing."""
 
+    @property
+    def name(self) -> str:
+        """Return the name of the effect."""
+        return "dummy"
+
     async def async_play(self) -> None:
         """Dummy play method."""
         pass

{lifx_async-4.3.0 → lifx_async-4.3.2}/tests/test_effects/test_pulse.py

@@ -14,6 +14,7 @@ def test_pulse_default_mode():
     """Test EffectPulse with default mode (blink)."""
     effect = EffectPulse()
 
+    assert effect.name == "pulse"
     assert effect.mode == "blink"
     assert effect.period == 1.0
     assert effect.cycles == 1

{lifx_async-4.3.0 → lifx_async-4.3.2}/uv.lock

@@ -432,7 +432,7 @@ wheels = [
 
 [[package]]
 name = "lifx-async"
-version = "4.3.0"
+version = "4.3.2"
 source = { editable = "." }
 
 [package.dev-dependencies]