Create common interfaces for remaining device types (#895)

Introduce common module interfaces across smart and iot devices and provide better typing implementation for getting modules to support this.

kasa/iot/modules/__init__.py

@@ -5,6 +5,7 @@ from .antitheft import Antitheft
 from .cloud import Cloud
 from .countdown import Countdown
 from .emeter import Emeter
+from .ledmodule import LedModule
 from .motion import Motion
 from .rulemodule import Rule, RuleModule
 from .schedule import Schedule
@@ -17,6 +18,7 @@ __all__ = [
     "Cloud",
     "Countdown",
     "Emeter",
+    "LedModule",
     "Motion",
     "Rule",
     "RuleModule",

kasa/iot/modules/ledmodule.py

@@ -0,0 +1,32 @@
+"""Module for led controls."""
+
+from __future__ import annotations
+
+from ...interfaces.led import Led
+from ..iotmodule import IotModule
+
+
+class LedModule(IotModule, Led):
+    """Implementation of led controls."""
+
+    def query(self) -> dict:
+        """Query to execute during the update cycle."""
+        return {}
+
+    @property
+    def mode(self):
+        """LED mode setting.
+
+        "always", "never"
+        """
+        return "always" if self.led else "never"
+
+    @property
+    def led(self) -> bool:
+        """Return the state of the led."""
+        sys_info = self.data
+        return bool(1 - sys_info["led_off"])
+
+    async def set_led(self, state: bool):
+        """Set the state of the led (night mode)."""
+        return await self.call("set_led_off", {"off": int(not state)})

kasa/iot/modules/lighteffectmodule.py

@@ -0,0 +1,97 @@
+"""Module for light effects."""
+
+from __future__ import annotations
+
+from ...interfaces.lighteffect import LightEffect
+from ..effects import EFFECT_MAPPING_V1, EFFECT_NAMES_V1
+from ..iotmodule import IotModule
+
+
+class LightEffectModule(IotModule, LightEffect):
+    """Implementation of dynamic light effects."""
+
+    @property
+    def effect(self) -> str:
+        """Return effect state.
+
+        Example:
+            {'brightness': 50,
+             'custom': 0,
+             'enable': 0,
+             'id': '',
+             'name': ''}
+        """
+        if (
+            (state := self.data.get("lighting_effect_state"))
+            and state.get("enable")
+            and (name := state.get("name"))
+            and name in EFFECT_NAMES_V1
+        ):
+            return name
+        return self.LIGHT_EFFECTS_OFF
+
+    @property
+    def effect_list(self) -> list[str]:
+        """Return built-in effects list.
+
+        Example:
+            ['Aurora', 'Bubbling Cauldron', ...]
+        """
+        effect_list = [self.LIGHT_EFFECTS_OFF]
+        effect_list.extend(EFFECT_NAMES_V1)
+        return effect_list
+
+    async def set_effect(
+        self,
+        effect: str,
+        *,
+        brightness: int | None = None,
+        transition: int | None = None,
+    ) -> None:
+        """Set an effect on the device.
+
+        If brightness or transition is defined,
+        its value will be used instead of the effect-specific default.
+
+        See :meth:`effect_list` for available effects,
+        or use :meth:`set_custom_effect` for custom effects.
+
+        :param str effect: The effect to set
+        :param int brightness: The wanted brightness
+        :param int transition: The wanted transition time
+        """
+        if effect == self.LIGHT_EFFECTS_OFF:
+            effect_dict = dict(self.data["lighting_effect_state"])
+            effect_dict["enable"] = 0
+        elif effect not in EFFECT_MAPPING_V1:
+            raise ValueError(f"The effect {effect} is not a built in effect.")
+        else:
+            effect_dict = EFFECT_MAPPING_V1[effect]
+        if brightness is not None:
+            effect_dict["brightness"] = brightness
+        if transition is not None:
+            effect_dict["transition"] = transition
+
+        await self.set_custom_effect(effect_dict)
+
+    async def set_custom_effect(
+        self,
+        effect_dict: dict,
+    ) -> None:
+        """Set a custom effect on the device.
+
+        :param str effect_dict: The custom effect dict to set
+        """
+        return await self.call(
+            "set_lighting_effect",
+            effect_dict,
+        )
+
+    @property
+    def has_custom_effects(self) -> bool:
+        """Return True if the device supports setting custom effects."""
+        return True
+
+    def query(self):
+        """Return the base query."""
+        return {}