Implement pydantic for lights

mypy.ini

@@ -190,3 +190,25 @@ disallow_untyped_defs = true
 no_implicit_optional = true
 warn_return_any = true
 warn_unreachable = true
+
+[mypy-pytradfri.device.light]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+warn_return_any = true
+warn_unreachable = true
+
+[mypy-pytradfri.device.light_control]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+warn_return_any = true
+warn_unreachable = true

pytradfri/device/__init__.py

@@ -24,6 +24,7 @@
     ROOT_DEVICES,
     ROOT_SIGNAL_REPEATER,
 )
+from ..device.light import LightResponse
 from ..resource import ApiResource, ApiResourceResponse
 from .air_purifier_control import AirPurifierControl, AirPurifierResponse
 from .blind_control import BlindControl, BlindResponse
@@ -56,7 +57,7 @@ class DeviceResponse(ApiResourceResponse):
     blind_control: Optional[List[BlindResponse]] = Field(alias=ATTR_START_BLINDS)
     device_info: DeviceInfoResponse = Field(alias=ATTR_DEVICE_INFO)
     last_seen: Optional[int] = Field(alias=ATTR_LAST_SEEN)
-    light_control: Optional[List[Dict[str, Any]]] = Field(alias=ATTR_LIGHT_CONTROL)
+    light_control: Optional[List[LightResponse]] = Field(alias=ATTR_LIGHT_CONTROL)
     reachable: int = Field(alias=ATTR_REACHABLE_STATE)
     signal_repeater_control: Optional[List[Dict[str, Any]]] = Field(
         alias=ROOT_SIGNAL_REPEATER

pytradfri/device/light.py

@@ -1,11 +1,14 @@
 """Represent a light."""
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
 
 from ..color import supported_features
 from ..const import (
     ATTR_DEVICE_STATE,
+    ATTR_ID,
     ATTR_LIGHT_COLOR_HEX,
     ATTR_LIGHT_COLOR_HUE,
     ATTR_LIGHT_COLOR_SATURATION,
@@ -19,6 +22,24 @@
     SUPPORT_XY_COLOR,
 )
 
+if TYPE_CHECKING:
+    # avoid cyclic import at runtime.
+    from . import Device
+
+
+class LightResponse(BaseModel):
+    """Represent API response for a blind."""
+
+    color_mireds: int | None = Field(alias=ATTR_LIGHT_MIREDS)
+    color_hex: str | None = Field(alias=ATTR_LIGHT_COLOR_HEX)
+    color_xy_x: int | None = Field(alias=ATTR_LIGHT_COLOR_X)
+    color_xy_y: int | None = Field(alias=ATTR_LIGHT_COLOR_Y)
+    color_hue: int | None = Field(alias=ATTR_LIGHT_COLOR_HUE)
+    color_saturation: int | None = Field(alias=ATTR_LIGHT_COLOR_SATURATION)
+    dimmer: int = Field(alias=ATTR_LIGHT_DIMMER)
+    id: int = Field(alias=ATTR_ID)
+    state: int = Field(alias=ATTR_DEVICE_STATE)
+
 
 class Light:
     """Represent a light.
@@ -27,69 +48,70 @@ class Light:
     pdf
     """
 
-    def __init__(self, device, index):
+    def __init__(self, device: Device, index: int):
         """Create object of class."""
         self.device = device
         self.index = index
 
     @property
-    def supported_features(self):
+    def supported_features(self) -> int:
         """Return supported features."""
-        return supported_features(self.raw)
+        return supported_features(self.raw.dict())
 
     @property
-    def state(self):
+    def state(self) -> bool:
         """Return device state."""
-        return self.raw.get(ATTR_DEVICE_STATE) == 1
+        return self.raw.state == 1
 
     @property
-    def dimmer(self):
+    def dimmer(self) -> int | None:
         """Return dimmer if present."""
         if self.supported_features & SUPPORT_BRIGHTNESS:
-            return self.raw.get(ATTR_LIGHT_DIMMER)
+            return self.raw.dimmer
         return None
 
     @property
-    def color_temp(self):
+    def color_temp(self) -> int | None:
         """Return color temperature."""
-        if self.supported_features & SUPPORT_COLOR_TEMP:
-            if self.raw.get(ATTR_LIGHT_MIREDS) != 0:
-                return self.raw.get(ATTR_LIGHT_MIREDS)
+        if self.supported_features & SUPPORT_COLOR_TEMP and self.raw.color_mireds:
+            return self.raw.color_mireds
         return None
 
     @property
-    def hex_color(self):
+    def hex_color(self) -> str | None:
         """Return hex color."""
         if self.supported_features & SUPPORT_HEX_COLOR:
-            return self.raw.get(ATTR_LIGHT_COLOR_HEX)
+            return self.raw.color_hex
         return None
 
     @property
-    def xy_color(self):
+    def xy_color(self) -> tuple[int | None, int | None] | None:
         """Return xy color."""
         if self.supported_features & SUPPORT_XY_COLOR:
-            return (self.raw.get(ATTR_LIGHT_COLOR_X), self.raw.get(ATTR_LIGHT_COLOR_Y))
+            return (self.raw.color_xy_x, self.raw.color_xy_y)
         return None
 
     @property
-    def hsb_xy_color(self):
+    def hsb_xy_color(
+        self,
+    ) -> tuple[int | None, int | None, int, int | None, int | None]:
         """Return hsb xy color."""
         return (
-            self.raw.get(ATTR_LIGHT_COLOR_HUE),
-            self.raw.get(ATTR_LIGHT_COLOR_SATURATION),
-            self.raw.get(ATTR_LIGHT_DIMMER),
-            self.raw.get(ATTR_LIGHT_COLOR_X),
-            self.raw.get(ATTR_LIGHT_COLOR_Y),
+            self.raw.color_hue,
+            self.raw.color_saturation,
+            self.raw.dimmer,
+            self.raw.color_xy_x,
+            self.raw.color_xy_y,
         )
 
     @property
-    def raw(self) -> dict[str, Any]:
+    def raw(self) -> LightResponse:
         """Return raw data that it represents."""
         light_control_response = self.device.raw.light_control
         assert light_control_response is not None
         return light_control_response[self.index]
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """Return representation of class object."""
         state = "on" if self.state else "off"
         return (

pytradfri/device/light_control.py

@@ -1,7 +1,7 @@
 """Class to control the lights."""
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from ..color import COLORS
 from ..command import Command
@@ -25,32 +25,36 @@
 )
 from ..error import ColorError
 from .base_controller import BaseController
-from .light import Light
+from .light import Light, LightResponse
+
+if TYPE_CHECKING:
+    # avoid cyclic import at runtime.
+    from . import Device
 
 
 class LightControl(BaseController):
     """Class to control the lights."""
 
-    def __init__(self, device):
+    def __init__(self, device: Device) -> None:
         """Create object of class."""
         super().__init__(device)
 
-        self.can_set_dimmer = None
-        self.can_set_temp = None
-        self.can_set_xy = None
-        self.can_set_color = None
-        self.can_combine_commands = None
+        self.can_set_dimmer: bool = False
+        self.can_set_temp: bool = False
+        self.can_set_xy: bool = False
+        self.can_set_color: bool = False
+        self.can_combine_commands: bool = False
 
-        if ATTR_LIGHT_DIMMER in self.raw[0]:
+        if ATTR_LIGHT_DIMMER in self.raw[0].dict():
             self.can_set_dimmer = True
 
-        if ATTR_LIGHT_MIREDS in self.raw[0]:
+        if ATTR_LIGHT_MIREDS in self.raw[0].dict():
             self.can_set_temp = True
 
-        if ATTR_LIGHT_COLOR_X in self.raw[0]:
+        if ATTR_LIGHT_COLOR_X in self.raw[0].dict():
             self.can_set_xy = True
 
-        if ATTR_LIGHT_COLOR_HUE in self.raw[0]:
+        if ATTR_LIGHT_COLOR_HUE in self.raw[0].dict():
             self.can_set_color = True
 
         # Currently uncertain which bulbs are capable of setting
@@ -70,22 +74,24 @@ def __init__(self, device):
         self.max_saturation = RANGE_SATURATION[1]
 
     @property
-    def raw(self) -> list[dict[str, Any]]:
+    def raw(self) -> list[LightResponse]:
         """Return raw data that it represents."""
         light_control_response = self._device.raw.light_control
         assert light_control_response is not None
         return light_control_response
 
     @property
-    def lights(self):
+    def lights(self) -> list[Light]:
         """Return light objects of the light control."""
         return [Light(self._device, i) for i in range(len(self.raw))]
 
-    def set_state(self, state, *, index=0):
+    def set_state(self, state: int, *, index: int = 0) -> Command:
         """Set state of a light."""
-        return self.set_values({ATTR_DEVICE_STATE: int(state)}, index=index)
+        return self.set_values({ATTR_DEVICE_STATE: state}, index=index)
 
-    def set_dimmer(self, dimmer, *, index=0, transition_time=None):
+    def set_dimmer(
+        self, dimmer: int, *, index: int = 0, transition_time: int | None = None
+    ) -> Command:
         """Set dimmer value of a light.
 
         transition_time: Integer representing tenth of a second (default None)
@@ -99,7 +105,9 @@ def set_dimmer(self, dimmer, *, index=0, transition_time=None):
 
         return self.set_values(values, index=index)
 
-    def set_color_temp(self, color_temp, *, index=0, transition_time=None):
+    def set_color_temp(
+        self, color_temp: int, *, index: int = 0, transition_time: int | None = None
+    ) -> Command:
         """Set color temp a light."""
         self._value_validate(color_temp, RANGE_MIREDS, "Color temperature")
 
@@ -110,9 +118,11 @@ def set_color_temp(self, color_temp, *, index=0, transition_time=None):
 
         return self.set_values(values, index=index)
 
-    def set_hex_color(self, color, *, index=0, transition_time=None):
+    def set_hex_color(
+        self, color: str, *, index: int = 0, transition_time: int | None = None
+    ) -> Command:
         """Set hex color of the light."""
-        values = {
+        values: dict[str, Any] = {
             ATTR_LIGHT_COLOR_HEX: color,
         }
 
@@ -121,7 +131,14 @@ def set_hex_color(self, color, *, index=0, transition_time=None):
 
         return self.set_values(values, index=index)
 
-    def set_xy_color(self, color_x, color_y, *, index=0, transition_time=None):
+    def set_xy_color(
+        self,
+        color_x: int,
+        color_y: int,
+        *,
+        index: int = 0,
+        transition_time: int | None = None,
+    ) -> Command:
         """Set xy color of the light."""
         self._value_validate(color_x, RANGE_X, "X color")
         self._value_validate(color_y, RANGE_Y, "Y color")
@@ -134,8 +151,14 @@ def set_xy_color(self, color_x, color_y, *, index=0, transition_time=None):
         return self.set_values(values, index=index)
 
     def set_hsb(
-        self, hue, saturation, brightness=None, *, index=0, transition_time=None
-    ):
+        self,
+        hue: int,
+        saturation: int,
+        brightness: int | None = None,
+        *,
+        index: int = 0,
+        transition_time: int | None = None,
+    ) -> Command:
         """Set HSB color settings of the light."""
         self._value_validate(hue, RANGE_HUE, "Hue")
         self._value_validate(saturation, RANGE_SATURATION, "Saturation")
@@ -151,7 +174,9 @@ def set_hsb(
 
         return self.set_values(values, index=index)
 
-    def set_predefined_color(self, colorname, *, index=0, transition_time=None):
+    def set_predefined_color(
+        self, colorname: str, *, index: int = 0, transition_time: int | None = None
+    ) -> Command:
         """Set predefined color."""
         try:
             color = COLORS[colorname.lower().replace(" ", "_")]
@@ -161,7 +186,7 @@ def set_predefined_color(self, colorname, *, index=0, transition_time=None):
         except KeyError:
             raise ColorError(f"Invalid color specified: {colorname}") from KeyError
 
-    def set_values(self, values, *, index=0):
+    def set_values(self, values: dict[str, Any], *, index: int = 0) -> Command:
         """Set values on light control.
 
         Returns a Command.