light.py

Go to the documentation of this file.

"""Support for Osram Lightify."""
 
from __future__ import annotations
 
import logging
import random
from typing import Any
 
from lightify import Lightify
import voluptuous as vol
 
from homeassistant.components.light import (
    ATTR_BRIGHTNESS,
    ATTR_COLOR_TEMP,
    ATTR_EFFECT,
    ATTR_HS_COLOR,
    ATTR_TRANSITION,
    EFFECT_RANDOM,
    PLATFORM_SCHEMA as LIGHT_PLATFORM_SCHEMA,
    ColorMode,
    LightEntity,
    LightEntityFeature,
    brightness_supported,
)
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
import homeassistant.util.color as color_util
 
_LOGGER = logging.getLogger(__name__)
 
CONF_ALLOW_LIGHTIFY_NODES = "allow_lightify_nodes"
CONF_ALLOW_LIGHTIFY_GROUPS = "allow_lightify_groups"
CONF_ALLOW_LIGHTIFY_SENSORS = "allow_lightify_sensors"
CONF_ALLOW_LIGHTIFY_SWITCHES = "allow_lightify_switches"
CONF_INTERVAL_LIGHTIFY_STATUS = "interval_lightify_status"
CONF_INTERVAL_LIGHTIFY_CONF = "interval_lightify_conf"
 
DEFAULT_ALLOW_LIGHTIFY_NODES = True
DEFAULT_ALLOW_LIGHTIFY_GROUPS = True
DEFAULT_ALLOW_LIGHTIFY_SENSORS = True
DEFAULT_ALLOW_LIGHTIFY_SWITCHES = True
DEFAULT_INTERVAL_LIGHTIFY_STATUS = 5
DEFAULT_INTERVAL_LIGHTIFY_CONF = 3600
 
PLATFORM_SCHEMA = LIGHT_PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_HOST): cv.string,
        vol.Optional(
            CONF_ALLOW_LIGHTIFY_NODES, default=DEFAULT_ALLOW_LIGHTIFY_NODES
        ): cv.boolean,
        vol.Optional(
            CONF_ALLOW_LIGHTIFY_GROUPS, default=DEFAULT_ALLOW_LIGHTIFY_GROUPS
        ): cv.boolean,
        vol.Optional(
            CONF_ALLOW_LIGHTIFY_SENSORS, default=DEFAULT_ALLOW_LIGHTIFY_SENSORS
        ): cv.boolean,
        vol.Optional(
            CONF_ALLOW_LIGHTIFY_SWITCHES, default=DEFAULT_ALLOW_LIGHTIFY_SWITCHES
        ): cv.boolean,
        vol.Optional(
            CONF_INTERVAL_LIGHTIFY_STATUS, default=DEFAULT_INTERVAL_LIGHTIFY_STATUS
        ): cv.positive_int,
        vol.Optional(
            CONF_INTERVAL_LIGHTIFY_CONF, default=DEFAULT_INTERVAL_LIGHTIFY_CONF
        ): cv.positive_int,
    }
)
 
DEFAULT_BRIGHTNESS = 2
DEFAULT_KELVIN = 2700
 
 
def setup_platform(
    hass: HomeAssistant,
    config: ConfigType,
    add_entities: AddEntitiesCallback,
    discovery_info: DiscoveryInfoType | None = None,
) -> None:
    """Set up the Osram Lightify lights."""
    host = config[CONF_HOST]
    try:
        bridge = Lightify(host, log_level=logging.NOTSET)
    except OSError:
        _LOGGER.exception("Error connecting to bridge %s", host)
        return
 
    setup_bridge(bridge, add_entities, config)
 
 
def setup_bridge(bridge, add_entities, config):
    """Set up the Lightify bridge."""
    lights = {}
    groups = {}
    groups_last_updated = [0]
 
    def update_lights():
        """Update the lights objects with the latest info from the bridge."""
        try:
            new_lights = bridge.update_all_light_status(
                config[CONF_INTERVAL_LIGHTIFY_STATUS]
            )
            lights_changed = bridge.lights_changed()
        except TimeoutError:
            _LOGGER.error("Timeout during updating of lights")
            return 0
        except OSError:
            _LOGGER.error("OSError during updating of lights")
            return 0
 
        if new_lights and config[CONF_ALLOW_LIGHTIFY_NODES]:
            new_entities = []
            for addr, light in new_lights.items():
                if (
                    light.devicetype().name == "SENSOR"
                    and not config[CONF_ALLOW_LIGHTIFY_SENSORS]
                ) or (
                    light.devicetype().name == "SWITCH"
                    and not config[CONF_ALLOW_LIGHTIFY_SWITCHES]
                ):
                    continue
 
                if addr not in lights:
                    osram_light = OsramLightifyLight(
                        light, update_lights, lights_changed
                    )
                    lights[addr] = osram_light
                    new_entities.append(osram_light)
                else:
                    lights[addr].update_luminary(light)
 
            add_entities(new_entities)
 
        return lights_changed
 
    def update_groups():
        """Update the groups objects with the latest info from the bridge."""
        lights_changed = update_lights()
 
        try:
            bridge.update_scene_list(config[CONF_INTERVAL_LIGHTIFY_CONF])
            new_groups = bridge.update_group_list(config[CONF_INTERVAL_LIGHTIFY_CONF])
            groups_updated = bridge.groups_updated()
        except TimeoutError:
            _LOGGER.error("Timeout during updating of scenes/groups")
            return 0
        except OSError:
            _LOGGER.error("OSError during updating of scenes/groups")
            return 0
 
        if new_groups:
            new_groups = {group.idx(): group for group in new_groups.values()}
            new_entities = []
            for idx, group in new_groups.items():
                if idx not in groups:
                    osram_group = OsramLightifyGroup(
                        group, update_groups, groups_updated
                    )
                    groups[idx] = osram_group
                    new_entities.append(osram_group)
                else:
                    groups[idx].update_luminary(group)
 
            add_entities(new_entities)
 
        if groups_updated > groups_last_updated[0]:
            groups_last_updated[0] = groups_updated
            for idx, osram_group in groups.items():
                if idx not in new_groups:
                    osram_group.update_static_attributes()
 
        return max(lights_changed, groups_updated)
 
    update_lights()
    if config[CONF_ALLOW_LIGHTIFY_GROUPS]:
        update_groups()
 
 
class Luminary(LightEntity):
    """Representation of Luminary Lights and Groups."""
 
    def __init__(self, luminary, update_func, changed):
        """Initialize a Luminary Light."""
        self.update_funcupdate_func = update_func
        self._luminary_luminary = luminary
        self._changed_changed = changed
 
        self._unique_id_unique_id = None
        self._effect_list_effect_list = []
        self._is_on_is_on = False
        self._available_available = True
        self._min_mireds_min_mireds = None
        self._max_mireds_max_mireds = None
        self._brightness_brightness = None
        self._color_temp_color_temp = None
        self._rgb_color_rgb_color = None
        self._device_attributes_device_attributes = None
 
        self.update_static_attributesupdate_static_attributes()
        self.update_dynamic_attributesupdate_dynamic_attributes()
 
    def _get_unique_id(self):
        """Get a unique ID (not implemented)."""
        raise NotImplementedError
 
    def _get_supported_color_modes(self) -> set[ColorMode]:
        """Get supported color modes."""
        color_modes: set[ColorMode] = set()
        if "temp" in self._luminary_luminary.supported_features():
            color_modes.add(ColorMode.COLOR_TEMP)
 
        if "rgb" in self._luminary_luminary.supported_features():
            color_modes.add(ColorMode.HS)
 
        if not color_modes and "lum" in self._luminary_luminary.supported_features():
            color_modes.add(ColorMode.BRIGHTNESS)
 
        if not color_modes:
            color_modes.add(ColorMode.ONOFF)
 
        return color_modes
 
    def _get_supported_features(self) -> LightEntityFeature:
        """Get list of supported features."""
        features = LightEntityFeature(0)
        if "lum" in self._luminary_luminary.supported_features():
            features = features | LightEntityFeature.TRANSITION
 
        if "temp" in self._luminary_luminary.supported_features():
            features = features | LightEntityFeature.TRANSITION
 
        if "rgb" in self._luminary_luminary.supported_features():
            features = (
                features | LightEntityFeature.TRANSITION | LightEntityFeature.EFFECT
            )
 
        return features
 
    def _get_effect_list(self):
        """Get list of supported effects."""
        effects = []
        if "rgb" in self._luminary_luminary.supported_features():
            effects.append(EFFECT_RANDOM)
 
        return effects
 
    @property
    def name(self):
        """Return the name of the luminary."""
        return self._luminary_luminary.name()
 
    @property
    def hs_color(self):
        """Return last hs color value set."""
        return color_util.color_RGB_to_hs(*self._rgb_color_rgb_color)
 
    @property
    def color_temp(self):
        """Return the color temperature."""
        return self._color_temp_color_temp
 
    @property
    def brightness(self):
        """Return brightness of the luminary (0..255)."""
        return self._brightness_brightness
 
    @property
    def is_on(self):
        """Return True if the device is on."""
        return self._is_on_is_on
 
    @property
    def effect_list(self):
        """List of supported effects."""
        return self._effect_list_effect_list
 
    @property
    def min_mireds(self):
        """Return the coldest color_temp that this light supports."""
        return self._min_mireds_min_mireds
 
    @property
    def max_mireds(self):
        """Return the warmest color_temp that this light supports."""
        return self._max_mireds_max_mireds
 
    @property
    def unique_id(self):
        """Return a unique ID."""
        return self._unique_id_unique_id
 
    @property
    def extra_state_attributes(self):
        """Return device specific state attributes."""
        return self._device_attributes_device_attributes
 
    @property
    def available(self):
        """Return True if entity is available."""
        return self._available_available
 
    def play_effect(self, effect, transition):
        """Play selected effect."""
        if effect == EFFECT_RANDOM:
            self._rgb_color_rgb_color = (
                random.randrange(0, 256),
                random.randrange(0, 256),
                random.randrange(0, 256),
            )
            self._luminary_luminary.set_rgb(*self._rgb_color_rgb_color, transition)
            self._luminary_luminary.set_onoff(True)
            return True
 
        return False
 
    def turn_on(self, **kwargs: Any) -> None:
        """Turn the device on."""
        transition = int(kwargs.get(ATTR_TRANSITION, 0) * 10)
        if ATTR_EFFECT in kwargs:
            self.play_effectplay_effect(kwargs[ATTR_EFFECT], transition)
            return
 
        if ATTR_HS_COLOR in kwargs:
            self._rgb_color_rgb_color = color_util.color_hs_to_RGB(*kwargs[ATTR_HS_COLOR])
            self._luminary_luminary.set_rgb(*self._rgb_color_rgb_color, transition)
 
        if ATTR_COLOR_TEMP in kwargs:
            self._color_temp_color_temp = kwargs[ATTR_COLOR_TEMP]
            self._luminary_luminary.set_temperature(
                int(color_util.color_temperature_mired_to_kelvin(self._color_temp_color_temp)),
                transition,
            )
 
        self._is_on_is_on = True
        if ATTR_BRIGHTNESS in kwargs:
            self._brightness_brightness = kwargs[ATTR_BRIGHTNESS]
            self._luminary_luminary.set_luminance(int(self._brightness_brightness / 2.55), transition)
        else:
            self._luminary_luminary.set_onoff(True)
 
    def turn_off(self, **kwargs: Any) -> None:
        """Turn the device off."""
        self._is_on_is_on = False
        if ATTR_TRANSITION in kwargs:
            transition = int(kwargs[ATTR_TRANSITION] * 10)
            self._brightness_brightness = DEFAULT_BRIGHTNESS
            self._luminary_luminary.set_luminance(0, transition)
        else:
            self._luminary_luminary.set_onoff(False)
 
    def update_luminary(self, luminary):
        """Update internal luminary object."""
        self._luminary_luminary = luminary
        self.update_static_attributesupdate_static_attributes()
 
    def update_static_attributes(self) -> None:
        """Update static attributes of the luminary."""
        self._unique_id_unique_id = self._get_unique_id_get_unique_id()
        self._attr_supported_color_modes_attr_supported_color_modes = self._get_supported_color_modes_get_supported_color_modes()
        self._attr_supported_features_attr_supported_features = self._get_supported_features_get_supported_features()
        self._effect_list_effect_list = self._get_effect_list_get_effect_list()
        if ColorMode.COLOR_TEMP in self._attr_supported_color_modes_attr_supported_color_modes:
            self._min_mireds_min_mireds = color_util.color_temperature_kelvin_to_mired(
                self._luminary_luminary.max_temp() or DEFAULT_KELVIN
            )
            self._max_mireds_max_mireds = color_util.color_temperature_kelvin_to_mired(
                self._luminary_luminary.min_temp() or DEFAULT_KELVIN
            )
        if len(self._attr_supported_color_modes_attr_supported_color_modes) == 1:
            # The light supports only a single color mode
            self._attr_color_mode_attr_color_mode = list(self._attr_supported_color_modes_attr_supported_color_modes)[0]
 
    def update_dynamic_attributes(self):
        """Update dynamic attributes of the luminary."""
        self._is_on_is_on = self._luminary_luminary.on()
        self._available_available = self._luminary_luminary.reachable() and not self._luminary_luminary.deleted()
        if brightness_supported(self._attr_supported_color_modes_attr_supported_color_modes):
            self._brightness_brightness = int(self._luminary_luminary.lum() * 2.55)
 
        if ColorMode.COLOR_TEMP in self._attr_supported_color_modes_attr_supported_color_modes:
            self._color_temp_color_temp = color_util.color_temperature_kelvin_to_mired(
                self._luminary_luminary.temp() or DEFAULT_KELVIN
            )
 
        if ColorMode.HS in self._attr_supported_color_modes_attr_supported_color_modes:
            self._rgb_color_rgb_color = self._luminary_luminary.rgb()
 
        if len(self._attr_supported_color_modes_attr_supported_color_modes) > 1:
            # The light supports hs + color temp, determine which one it is
            if self._rgb_color_rgb_color == (0, 0, 0):
                self._attr_color_mode_attr_color_mode = ColorMode.COLOR_TEMP
            else:
                self._attr_color_mode_attr_color_mode = ColorMode.HS
 
    def update(self) -> None:
        """Synchronize state with bridge."""
        changed = self.update_funcupdate_func()
        if changed > self._changed_changed:
            self._changed_changed = changed
            self.update_dynamic_attributesupdate_dynamic_attributes()
 
 
class OsramLightifyLight(Luminary):
    """Representation of an Osram Lightify Light."""
 
    def _get_unique_id(self):
        """Get a unique ID."""
        return self._luminary_luminary.addr()
 
    def update_static_attributes(self):
        """Update static attributes of the luminary."""
        super().update_static_attributes()
        attrs = {
            "device_type": (
                f"{self._luminary.type_id()} ({self._luminary.devicename()})"
            ),
            "firmware_version": self._luminary_luminary.version(),
        }
        if self._luminary_luminary.devicetype().name == "SENSOR":
            attrs["sensor_values"] = self._luminary_luminary.raw_values()
 
        self._device_attributes_device_attributes_device_attributes = attrs
 
 
class OsramLightifyGroup(Luminary):
    """Representation of an Osram Lightify Group."""
 
    def _get_unique_id(self):
        """Get a unique ID for the group."""
        #       Actually, it's a wrong choice for a unique ID, because a combination of
        #       lights is NOT unique (Osram Lightify allows to create different groups
        #       with the same lights). Also a combination of lights may easily change,
        #       but the group remains the same from the user's perspective.
        #       It should be something like "<gateway host>-<group.idx()>"
        #       For now keeping it as is for backward compatibility with existing
        #       users.
        return f"{self._luminary.lights()}"
 
    def _get_supported_features(self) -> LightEntityFeature:
        """Get list of supported features."""
        features = super()._get_supported_features()
        if self._luminary_luminary.scenes():
            features |= LightEntityFeature.EFFECT
 
        return features
 
    def _get_effect_list(self):
        """Get list of supported effects."""
        effects = super()._get_effect_list()
        effects.extend(self._luminary_luminary.scenes())
        return sorted(effects)
 
    def play_effect(self, effect, transition):
        """Play selected effect."""
        if super().play_effect(effect, transition):
            return True
 
        if effect in self._luminary_luminary.scenes():
            self._luminary_luminary.activate_scene(effect)
            return True
 
        return False
 
    def update_static_attributes(self):
        """Update static attributes of the luminary."""
        super().update_static_attributes()
        self._device_attributes_device_attributes_device_attributes = {"lights": self._luminary_luminary.light_names()}