Merge remote-tracking branch 'upstream/master' into feat/light_module_feats

kasa/smart/modules/__init__.py

@@ -16,6 +16,7 @@ from .energy import Energy
 from .fan import Fan
 from .firmware import Firmware
 from .frostprotection import FrostProtection
+from .homekit import HomeKit
 from .humiditysensor import HumiditySensor
 from .led import Led
 from .light import Light
@@ -23,6 +24,7 @@ from .lighteffect import LightEffect
 from .lightpreset import LightPreset
 from .lightstripeffect import LightStripEffect
 from .lighttransition import LightTransition
+from .matter import Matter
 from .motionsensor import MotionSensor
 from .overheatprotection import OverheatProtection
 from .reportmode import ReportMode
@@ -66,4 +68,6 @@ __all__ = [
     "Thermostat",
     "SmartLightEffect",
     "OverheatProtection",
+    "HomeKit",
+    "Matter",
 ]

kasa/smart/modules/energy.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
-from typing import NoReturn
+from typing import Any, NoReturn
 
 from ...emeterstatus import EmeterStatus
-from ...exceptions import KasaException
+from ...exceptions import DeviceError, KasaException
 from ...interfaces.energy import Energy as EnergyInterface
 from ..smartmodule import SmartModule, raise_if_update_error
 
@@ -15,12 +15,39 @@ class Energy(SmartModule, EnergyInterface):
 
     REQUIRED_COMPONENT = "energy_monitoring"
 
+    _energy: dict[str, Any]
+    _current_consumption: float | None
+
     async def _post_update_hook(self) -> None:
-        if "voltage_mv" in self.data.get("get_emeter_data", {}):
+        try:
+            data = self.data
+        except DeviceError as de:
+            self._energy = {}
+            self._current_consumption = None
+            raise de
+
+        # If version is 1 then data is get_energy_usage
+        self._energy = data.get("get_energy_usage", data)
+
+        if "voltage_mv" in data.get("get_emeter_data", {}):
             self._supported = (
                 self._supported | EnergyInterface.ModuleFeature.VOLTAGE_CURRENT
             )
 
+        if (power := self._energy.get("current_power")) is not None or (
+            power := data.get("get_emeter_data", {}).get("power_mw")
+        ) is not None:
+            self._current_consumption = power / 1_000
+        # Fallback if get_energy_usage does not provide current_power,
+        # which can happen on some newer devices (e.g. P304M).
+        # This may not be valid scenario as it pre-dates trying get_emeter_data
+        elif (
+            power := self.data.get("get_current_power", {}).get("current_power")
+        ) is not None:
+            self._current_consumption = power
+        else:
+            self._current_consumption = None
+
     def query(self) -> dict:
         """Query to execute during the update cycle."""
         req = {
@@ -33,28 +60,21 @@ class Energy(SmartModule, EnergyInterface):
         return req
 
     @property
-    @raise_if_update_error
-    def current_consumption(self) -> float | None:
-        """Current power in watts."""
-        if (power := self.energy.get("current_power")) is not None or (
-            power := self.data.get("get_emeter_data", {}).get("power_mw")
-        ) is not None:
-            return power / 1_000
-        # Fallback if get_energy_usage does not provide current_power,
-        # which can happen on some newer devices (e.g. P304M).
-        elif (
-            power := self.data.get("get_current_power", {}).get("current_power")
-        ) is not None:
-            return power
-        return None
+    def optional_response_keys(self) -> list[str]:
+        """Return optional response keys for the module."""
+        if self.supported_version > 1:
+            return ["get_energy_usage"]
+        return []
+
+    @property
+    def current_consumption(self) -> float | None:
+        """Current power in watts."""
+        return self._current_consumption
 
     @property
-    @raise_if_update_error
     def energy(self) -> dict:
         """Return get_energy_usage results."""
-        if en := self.data.get("get_energy_usage"):
-            return en
-        return self.data
+        return self._energy
 
     def _get_status_from_energy(self, energy: dict) -> EmeterStatus:
         return EmeterStatus(
@@ -83,16 +103,18 @@ class Energy(SmartModule, EnergyInterface):
             return self._get_status_from_energy(res["get_energy_usage"])
 
     @property
-    @raise_if_update_error
     def consumption_this_month(self) -> float | None:
         """Get the emeter value for this month in kWh."""
-        return self.energy.get("month_energy", 0) / 1_000
+        if (month := self.energy.get("month_energy")) is not None:
+            return month / 1_000
+        return None
 
     @property
-    @raise_if_update_error
     def consumption_today(self) -> float | None:
         """Get the emeter value for today in kWh."""
-        return self.energy.get("today_energy", 0) / 1_000
+        if (today := self.energy.get("today_energy")) is not None:
+            return today / 1_000
+        return None
 
     @property
     @raise_if_update_error

kasa/smart/modules/homekit.py

@@ -0,0 +1,32 @@
+"""Implementation of homekit module."""
+
+from __future__ import annotations
+
+from ...feature import Feature
+from ..smartmodule import SmartModule
+
+
+class HomeKit(SmartModule):
+    """Implementation of homekit module."""
+
+    QUERY_GETTER_NAME: str = "get_homekit_info"
+    REQUIRED_COMPONENT = "homekit"
+
+    def _initialize_features(self) -> None:
+        """Initialize features after the initial update."""
+        self._add_feature(
+            Feature(
+                self._device,
+                id="homekit_setup_code",
+                name="Homekit setup code",
+                container=self,
+                attribute_getter=lambda x: x.info["mfi_setup_code"],
+                type=Feature.Type.Sensor,
+                category=Feature.Category.Debug,
+            )
+        )
+
+    @property
+    def info(self) -> dict[str, str]:
+        """Homekit mfi setup info."""
+        return self.data

kasa/smart/modules/light.py

@@ -136,16 +136,17 @@ class Light(SmartModule, LightInterface):
         return self._light_state
 
     async def _post_update_hook(self) -> None:
-        if self._device.is_on is False:
+        device = self._device
+        if device.is_on is False:
             state = LightState(light_on=False)
         else:
             state = LightState(light_on=True)
-            if Module.Brightness in self._device.modules:
+            if Module.Brightness in device.modules:
                 state.brightness = self.brightness
-            if Module.Color in self._device.modules:
+            if Module.Color in device.modules:
                 hsv = self.hsv
                 state.hue = hsv.hue
                 state.saturation = hsv.saturation
-            if Module.ColorTemperature in self._device.modules:
+            if Module.ColorTemperature in device.modules:
                 state.color_temp = self.color_temp
         self._light_state = state

kasa/smart/modules/matter.py

@@ -0,0 +1,43 @@
+"""Implementation of matter module."""
+
+from __future__ import annotations
+
+from ...feature import Feature
+from ..smartmodule import SmartModule
+
+
+class Matter(SmartModule):
+    """Implementation of matter module."""
+
+    QUERY_GETTER_NAME: str = "get_matter_setup_info"
+    REQUIRED_COMPONENT = "matter"
+
+    def _initialize_features(self) -> None:
+        """Initialize features after the initial update."""
+        self._add_feature(
+            Feature(
+                self._device,
+                id="matter_setup_code",
+                name="Matter setup code",
+                container=self,
+                attribute_getter=lambda x: x.info["setup_code"],
+                type=Feature.Type.Sensor,
+                category=Feature.Category.Debug,
+            )
+        )
+        self._add_feature(
+            Feature(
+                self._device,
+                id="matter_setup_payload",
+                name="Matter setup payload",
+                container=self,
+                attribute_getter=lambda x: x.info["setup_payload"],
+                type=Feature.Type.Sensor,
+                category=Feature.Category.Debug,
+            )
+        )
+
+    @property
+    def info(self) -> dict[str, str]:
+        """Matter setup info."""
+        return self.data