feat: add support for lights

Author: muhlba91

README.md

@@ -73,6 +73,7 @@ Once configured, the integration **creates entities** for:
 | Entity               | Description                                                                                                      |
 |----------------------|------------------------------------------------------------------------------------------------------------------|
 | Cover                | Manage the shutter. ([API Reference](https://developers.home-assistant.io/docs/core/entity/cover/))              |
+| Light                | Manage the (dimmable) light. ([API Reference](https://developers.home-assistant.io/docs/core/entity/light/))              |
 | Sensor (Device Type) | The device type of the ONYX device. ([API Reference](https://developers.home-assistant.io/docs/core/entity/sensor/)) |
 | Sensor (Weather Humidity) | The humidity of the weather sensor. ([API Reference](https://developers.home-assistant.io/docs/core/entity/sensor/)) |
 | Sensor (Weather Temperature) | The temperature of the weather sensor. ([API Reference](https://developers.home-assistant.io/docs/core/entity/sensor/)) |

custom_components/hella_onyx/light.py

@@ -0,0 +1,39 @@
+"""The ONYX light entity."""
+import logging
+from typing import Callable, Optional
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.typing import DiscoveryInfoType
+
+from custom_components.hella_onyx import DOMAIN, ONYX_TIMEZONE
+from custom_components.hella_onyx.const import ONYX_API, ONYX_COORDINATOR
+from custom_components.hella_onyx.sensors.light import OnyxLight
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: Callable,
+    discovery_info: Optional[DiscoveryInfoType] = None,
+):
+    """Set up the ONYX light platform."""
+    data = hass.data[DOMAIN][entry.entry_id]
+    api = data[ONYX_API]
+    timezone = data[ONYX_TIMEZONE]
+    coordinator = data[ONYX_COORDINATOR]
+
+    lights = [
+        OnyxLight(
+            api, timezone, coordinator, device.name, device.device_type, device_id
+        )
+        for device_id, device in filter(
+            lambda item: item[1].device_type is not None
+            and item[1].device_type.is_light(),
+            api.devices.items(),
+        )
+    ]
+    _LOGGER.info("adding %s hella_onyx light entities", len(lights))
+    async_add_entities(lights, True)

custom_components/hella_onyx/sensors/light.py

@@ -0,0 +1,130 @@
+"""The ONYX light entity."""
+import asyncio
+import logging
+from math import ceil
+from typing import Any
+
+from homeassistant.components.light import (
+    LightEntity,
+    ColorMode,
+    ATTR_BRIGHTNESS,
+)
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from onyx_client.enum.action import Action
+from onyx_client.enum.device_type import DeviceType
+
+from custom_components.hella_onyx.api_connector import APIConnector
+from custom_components.hella_onyx.sensors.onyx_entity import OnyxEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+MIN_USED_DIM_DURATION = 500
+MAX_USED_DIM_DURATION = 6000
+
+
+class OnyxLight(OnyxEntity, LightEntity):
+    """A light entity."""
+
+    def __init__(
+        self,
+        api: APIConnector,
+        timezone: str,
+        coordinator: DataUpdateCoordinator,
+        name: str,
+        device_type: DeviceType,
+        uuid: str,
+    ):
+        """Initialize a light entity."""
+        super().__init__(api, timezone, coordinator, name, device_type, uuid)
+
+    @property
+    def icon(self) -> str:
+        """Icon to use in the frontend, if any."""
+        return "mdi:lightbulb-on-outline"
+
+    @property
+    def name(self) -> str:
+        """Return the display name of the sensor."""
+        return self._name
+
+    @property
+    def unique_id(self) -> str:
+        """Return the unique id of the sensor."""
+        return f"{self._uuid}/Light"
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return []
+
+    @property
+    def color_mode(self) -> ColorMode | str | None:
+        """Return the color mode of the light."""
+        return (
+            ColorMode.ONOFF
+            if self._device.device_type == DeviceType.BASIC_LIGHT
+            else ColorMode.BRIGHTNESS
+        )
+
+    @property
+    def supported_color_modes(self) -> set[ColorMode] | set[str] | None:
+        """Flag supported color modes."""
+        return [self.color_mode]
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the brightness of this light between 0..255."""
+        brightness = self._device.actual_brightness
+        _LOGGER.debug(
+            "received brightness for device %s: %s (%s/%s)",
+            self._uuid,
+            brightness.value,
+            brightness.minimum,
+            brightness.maximum,
+        )
+        return brightness.value / brightness.maximum * 255
+
+    def turn_on(self, **kwargs: Any) -> None:
+        """Turns the light on."""
+        hella_brightness = ceil(
+            kwargs[ATTR_BRIGHTNESS] / 255 * self._device.actual_brightness.maximum
+        )
+        dim_duration = self._get_dim_duration(hella_brightness)
+        _LOGGER.debug(
+            "setting brightness for device %s: %s (%s)",
+            self._uuid,
+            hella_brightness,
+            dim_duration,
+        )
+        asyncio.run_coroutine_threadsafe(
+            self.api.send_device_command_properties(
+                self._uuid,
+                {
+                    "target_brightness": hella_brightness,
+                    "dim_duration": dim_duration,
+                },
+            ),
+            self.hass.loop,
+        )
+
+    def turn_off(self, **kwargs: Any) -> None:
+        """Turns the light off."""
+        _LOGGER.debug(
+            "turning light off %s",
+            self._uuid,
+        )
+        asyncio.run_coroutine_threadsafe(
+            self.api.send_device_command_action(self._uuid, Action.LIGHT_OFF),
+            self.hass.loop,
+        )
+
+    def _get_dim_duration(self, target) -> int:
+        """Get the dim duration."""
+        return abs(
+            int(
+                (target - self._device.actual_brightness.value)
+                / self._device.actual_brightness.maximum
+                * (MAX_USED_DIM_DURATION - MIN_USED_DIM_DURATION)
+                + MIN_USED_DIM_DURATION
+            )
+        )

custom_components/hella_onyx/sensors/shutter.py

@@ -94,7 +94,7 @@ def current_cover_position(self) -> int:
         """
         position = self._device.actual_position
         _LOGGER.debug(
-            "received position fo device %s: %s (%s/%s)",
+            "received position for device %s: %s (%s/%s)",
             self._uuid,
             position.value,
             position.minimum,
@@ -112,7 +112,7 @@ def current_cover_tilt_position(self) -> int:
         """
         position = self._device.actual_angle
         _LOGGER.debug(
-            "received tilt position fo device %s: %s (%s/%s)",
+            "received tilt position for device %s: %s (%s/%s)",
             self._uuid,
             position.value,
             position.minimum,

tests/sensors/test_light.py

@@ -0,0 +1,133 @@
+"""Test for the ONYX Light Entity."""
+from unittest.mock import MagicMock, patch
+
+import pytest
+from homeassistant.components.light import (
+    ColorMode,
+)
+from homeassistant.core import HomeAssistant
+from onyx_client.data.numeric_value import NumericValue
+from onyx_client.device.light import Light
+from onyx_client.enum.action import Action
+from onyx_client.enum.device_type import DeviceType
+
+from custom_components.hella_onyx.light import OnyxLight
+
+
+class TestOnyxLight:
+    @pytest.fixture
+    def api(self):
+        yield MagicMock()
+
+    @pytest.fixture
+    def coordinator(self):
+        yield MagicMock()
+
+    @pytest.fixture
+    def hass(self):
+        hass = MagicMock(spec=HomeAssistant)
+        hass.loop = MagicMock()
+        yield hass
+
+    @pytest.fixture
+    def entity(self, api, coordinator, hass):
+        shutter = OnyxLight(
+            api, "UTC", coordinator, "name", DeviceType.BASIC_LIGHT, "uuid"
+        )
+        shutter.hass = hass
+        yield shutter
+
+    @pytest.fixture
+    def dimmable_entity(self, api, coordinator):
+        yield OnyxLight(
+            api, "UTC", coordinator, "name", DeviceType.DIMMABLE_LIGHT, "uuid"
+        )
+
+    @pytest.fixture
+    def device(self):
+        yield Light(
+            "id",
+            "name",
+            DeviceType.BASIC_LIGHT,
+            None,
+            list(Action),
+        )
+
+    def test_icon(self, entity):
+        assert entity.icon == "mdi:lightbulb-on-outline"
+
+    def test_name(self, entity):
+        assert entity.name == "name"
+
+    def test_unique_id(self, entity):
+        assert entity.unique_id == "uuid/Light"
+
+    def test_supported_features(self, entity):
+        assert len(entity.supported_features) == 0
+
+    def test_color_mode(self, api, entity, device):
+        device.device_type = DeviceType.BASIC_LIGHT
+        api.device.return_value = device
+        assert entity.color_mode == ColorMode.ONOFF
+        assert len(entity.supported_color_modes) == 1
+        assert entity.supported_color_modes[0] == ColorMode.ONOFF
+        assert api.device.called
+
+    def test_color_mode_brightness(self, api, dimmable_entity, device):
+        device.device_type = DeviceType.DIMMABLE_LIGHT
+        api.device.return_value = device
+        assert dimmable_entity.color_mode == ColorMode.BRIGHTNESS
+        assert len(dimmable_entity.supported_color_modes) == 1
+        assert dimmable_entity.supported_color_modes[0] == ColorMode.BRIGHTNESS
+        assert api.device.called
+
+    def test_brightness(self, api, entity, device):
+        device.actual_brightness = NumericValue(
+            value=10, minimum=0, maximum=100, read_only=False
+        )
+        api.device.return_value = device
+        assert entity.brightness == 25.5
+        assert api.device.called
+
+    @patch("asyncio.run_coroutine_threadsafe")
+    def test_turn_off(self, mock_run_coroutine_threadsafe, api, entity, device):
+        device.actual_brightness = NumericValue(
+            value=100, maximum=100, minimum=0, read_only=False
+        )
+        api.device.return_value = device
+        entity.turn_off()
+        api.send_device_command_action.assert_called_with("uuid", Action.LIGHT_OFF)
+        assert mock_run_coroutine_threadsafe.called
+
+    @patch("asyncio.run_coroutine_threadsafe")
+    def test_turn_on(self, mock_run_coroutine_threadsafe, api, entity, device):
+        device.actual_brightness = NumericValue(
+            value=100, maximum=100, minimum=0, read_only=False
+        )
+        api.device.return_value = device
+        entity.turn_on(brightness=10)
+        api.send_device_command_properties.assert_called_with(
+            "uuid",
+            {
+                "target_brightness": 4,
+                "dim_duration": 4780,
+            },
+        )
+        assert mock_run_coroutine_threadsafe.called
+        assert api.device.called
+
+    def test__get_dim_duration(self, api, entity, device):
+        device.actual_brightness = NumericValue(
+            value=100, maximum=100, minimum=0, read_only=False
+        )
+        api.device.return_value = device
+        assert entity._get_dim_duration(90) == 50
+        assert api.device.called
+
+    def test__get_dim_duration_same(self, api, entity, device):
+        device.actual_brightness = NumericValue(
+            value=100, maximum=100, minimum=0, read_only=False
+        )
+        api.device.return_value = device
+        assert entity._get_dim_duration(100) == 500
+        assert api.device.called