Add adaptive_lighting component

CODEOWNERS

@@ -22,6 +22,7 @@ homeassistant/scripts/check_config.py @kellerza
 homeassistant/components/abode/* @shred86
 homeassistant/components/accuweather/* @bieniu
 homeassistant/components/acmeda/* @atmurray
+homeassistant/components/adaptive_lighting/* @basnijholt
 homeassistant/components/adguard/* @frenck
 homeassistant/components/advantage_air/* @Bre77
 homeassistant/components/agent_dvr/* @ispysoftware

homeassistant/components/adaptive_lighting/__init__.py

@@ -0,0 +1,90 @@
+"""Adaptive Lighting integration in Home-Assistant."""
+import logging
+from typing import Any, Dict
+
+import voluptuous as vol
+
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.const import CONF_SOURCE
+from homeassistant.core import HomeAssistant
+import homeassistant.helpers.config_validation as cv
+
+from .const import (
+    _DOMAIN_SCHEMA,
+    ATTR_TURN_ON_OFF_LISTENER,
+    CONF_NAME,
+    DOMAIN,
+    UNDO_UPDATE_LISTENER,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS = ["switch"]
+
+
+def _all_unique_names(value):
+    """Validate that all entities have a unique profile name."""
+    hosts = [device[CONF_NAME] for device in value]
+    schema = vol.Schema(vol.Unique())
+    schema(hosts)
+    return value
+
+
+CONFIG_SCHEMA = vol.Schema(
+    {DOMAIN: vol.All(cv.ensure_list, [_DOMAIN_SCHEMA], _all_unique_names)},
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+async def async_setup(hass: HomeAssistant, config: Dict[str, Any]):
+    """Import integration from config."""
+
+    if DOMAIN in config:
+        for entry in config[DOMAIN]:
+            hass.async_create_task(
+                hass.config_entries.flow.async_init(
+                    DOMAIN, context={CONF_SOURCE: SOURCE_IMPORT}, data=entry
+                )
+            )
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Set up the component."""
+    data = hass.data.setdefault(DOMAIN, {})
+
+    undo_listener = config_entry.add_update_listener(async_update_options)
+    data[config_entry.entry_id] = {UNDO_UPDATE_LISTENER: undo_listener}
+    for platform in PLATFORMS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(config_entry, platform)
+        )
+
+    return True
+
+
+async def async_update_options(hass, config_entry: ConfigEntry):
+    """Update options."""
+    await hass.config_entries.async_reload(config_entry.entry_id)
+
+
+async def async_unload_entry(hass, config_entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_forward_entry_unload(
+        config_entry, "switch"
+    )
+    data = hass.data[DOMAIN]
+    data[config_entry.entry_id][UNDO_UPDATE_LISTENER]()
+    if unload_ok:
+        data.pop(config_entry.entry_id)
+
+    if len(data) == 1 and ATTR_TURN_ON_OFF_LISTENER in data:
+        # no more config_entries
+        turn_on_off_listener = data.pop(ATTR_TURN_ON_OFF_LISTENER)
+        turn_on_off_listener.remove_listener()
+        turn_on_off_listener.remove_listener2()
+
+    if not data:
+        hass.data.pop(DOMAIN)
+
+    return unload_ok

homeassistant/components/adaptive_lighting/config_flow.py

@@ -0,0 +1,109 @@
+"""Config flow for Adaptive Lighting integration."""
+import logging
+
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_NAME
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+
+from .const import (  # pylint: disable=unused-import
+    CONF_LIGHTS,
+    DOMAIN,
+    EXTRA_VALIDATION,
+    NONE_STR,
+    VALIDATION_TUPLES,
+)
+from .switch import _supported_features
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Adaptive Lighting."""
+
+    VERSION = 1
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+
+        if user_input is not None:
+            await self.async_set_unique_id(user_input[CONF_NAME])
+            self._abort_if_unique_id_configured()
+            return self.async_create_entry(title=user_input[CONF_NAME], data=user_input)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({vol.Required(CONF_NAME): str}),
+            errors=errors,
+        )
+
+    async def async_step_import(self, user_input=None):
+        """Handle configuration by yaml file."""
+        await self.async_set_unique_id(user_input[CONF_NAME])
+        for entry in self._async_current_entries():
+            if entry.unique_id == self.unique_id:
+                self.hass.config_entries.async_update_entry(entry, data=user_input)
+                self._abort_if_unique_id_configured()
+        return self.async_create_entry(title=user_input[CONF_NAME], data=user_input)
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry):
+        """Get the options flow for this handler."""
+        return OptionsFlowHandler(config_entry)
+
+
+def validate_options(user_input, errors):
+    """Validate the options in the OptionsFlow.
+
+    This is an extra validation step because the validators
+    in `EXTRA_VALIDATION` cannot be serialized to json.
+    """
+    for key, (validate, _) in EXTRA_VALIDATION.items():
+        # these are unserializable validators
+        value = user_input.get(key)
+        try:
+            if value is not None and value != NONE_STR:
+                validate(value)
+        except vol.Invalid:
+            _LOGGER.exception("Configuration option %s=%s is incorrect", key, value)
+            errors["base"] = "option_error"
+
+
+class OptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle a option flow for Adaptive Lighting."""
+
+    def __init__(self, config_entry: config_entries.ConfigEntry):
+        """Initialize options flow."""
+        self.config_entry = config_entry
+
+    async def async_step_init(self, user_input=None):
+        """Handle options flow."""
+        conf = self.config_entry
+        if conf.source == config_entries.SOURCE_IMPORT:
+            return self.async_show_form(step_id="init", data_schema=None)
+        errors = {}
+        if user_input is not None:
+            validate_options(user_input, errors)
+            if not errors:
+                return self.async_create_entry(title="", data=user_input)
+
+        all_lights = [
+            light
+            for light in self.hass.states.async_entity_ids("light")
+            if _supported_features(self.hass, light)
+        ]
+        to_replace = {CONF_LIGHTS: cv.multi_select(sorted(all_lights))}
+
+        options_schema = {}
+        for name, default, validation in VALIDATION_TUPLES:
+            key = vol.Optional(name, default=conf.options.get(name, default))
+            value = to_replace.get(name, validation)
+            options_schema[key] = value
+
+        return self.async_show_form(
+            step_id="init", data_schema=vol.Schema(options_schema), errors=errors
+        )

homeassistant/components/adaptive_lighting/const.py

@@ -0,0 +1,127 @@
+"""Constants for the Adaptive Lighting integration."""
+import voluptuous as vol
+
+from homeassistant.components.light import VALID_TRANSITION
+import homeassistant.helpers.config_validation as cv
+
+ICON = "mdi:theme-light-dark"
+
+DOMAIN = "adaptive_lighting"
+SUN_EVENT_NOON = "solar_noon"
+SUN_EVENT_MIDNIGHT = "solar_midnight"
+
+CONF_NAME, DEFAULT_NAME = "name", "default"
+CONF_LIGHTS, DEFAULT_LIGHTS = "lights", []
+CONF_DETECT_NON_HA_CHANGES, DEFAULT_DETECT_NON_HA_CHANGES = (
+    "detect_non_ha_changes",
+    False,
+)
+CONF_INITIAL_TRANSITION, DEFAULT_INITIAL_TRANSITION = "initial_transition", 1
+CONF_INTERVAL, DEFAULT_INTERVAL = "interval", 90
+CONF_MAX_BRIGHTNESS, DEFAULT_MAX_BRIGHTNESS = "max_brightness", 100
+CONF_MAX_COLOR_TEMP, DEFAULT_MAX_COLOR_TEMP = "max_color_temp", 5500
+CONF_MIN_BRIGHTNESS, DEFAULT_MIN_BRIGHTNESS = "min_brightness", 1
+CONF_MIN_COLOR_TEMP, DEFAULT_MIN_COLOR_TEMP = "min_color_temp", 2000
+CONF_ONLY_ONCE, DEFAULT_ONLY_ONCE = "only_once", False
+CONF_PREFER_RGB_COLOR, DEFAULT_PREFER_RGB_COLOR = "prefer_rgb_color", False
+CONF_SEPARATE_TURN_ON_COMMANDS, DEFAULT_SEPARATE_TURN_ON_COMMANDS = (
+    "separate_turn_on_commands",
+    False,
+)
+CONF_SLEEP_BRIGHTNESS, DEFAULT_SLEEP_BRIGHTNESS = "sleep_brightness", 1
+CONF_SLEEP_COLOR_TEMP, DEFAULT_SLEEP_COLOR_TEMP = "sleep_color_temp", 1000
+CONF_SUNRISE_OFFSET, DEFAULT_SUNRISE_OFFSET = "sunrise_offset", 0
+CONF_SUNRISE_TIME = "sunrise_time"
+CONF_SUNSET_OFFSET, DEFAULT_SUNSET_OFFSET = "sunset_offset", 0
+CONF_SUNSET_TIME = "sunset_time"
+CONF_TAKE_OVER_CONTROL, DEFAULT_TAKE_OVER_CONTROL = "take_over_control", True
+CONF_TRANSITION, DEFAULT_TRANSITION = "transition", 45
+
+SLEEP_MODE_SWITCH = "sleep_mode_switch"
+ADAPT_COLOR_SWITCH = "adapt_color_switch"
+ADAPT_BRIGHTNESS_SWITCH = "adapt_brightness_switch"
+ATTR_TURN_ON_OFF_LISTENER = "turn_on_off_listener"
+UNDO_UPDATE_LISTENER = "undo_update_listener"
+NONE_STR = "None"
+ATTR_ADAPT_COLOR = "adapt_color"
+ATTR_ADAPT_BRIGHTNESS = "adapt_brightness"
+
+SERVICE_SET_MANUAL_CONTROL = "set_manual_control"
+CONF_MANUAL_CONTROL = "manual_control"
+SERVICE_APPLY = "apply"
+CONF_TURN_ON_LIGHTS = "turn_on_lights"
+
+TURNING_OFF_DELAY = 5
+
+
+def int_between(min_int, max_int):
+    """Return an integer between 'min_int' and 'max_int'."""
+    return vol.All(vol.Coerce(int), vol.Range(min=min_int, max=max_int))
+
+
+VALIDATION_TUPLES = [
+    (CONF_LIGHTS, DEFAULT_LIGHTS, cv.entity_ids),
+    (CONF_PREFER_RGB_COLOR, DEFAULT_PREFER_RGB_COLOR, bool),
+    (CONF_INITIAL_TRANSITION, DEFAULT_INITIAL_TRANSITION, VALID_TRANSITION),
+    (CONF_TRANSITION, DEFAULT_TRANSITION, VALID_TRANSITION),
+    (CONF_INTERVAL, DEFAULT_INTERVAL, cv.positive_int),
+    (CONF_MIN_BRIGHTNESS, DEFAULT_MIN_BRIGHTNESS, int_between(1, 100)),
+    (CONF_MAX_BRIGHTNESS, DEFAULT_MAX_BRIGHTNESS, int_between(1, 100)),
+    (CONF_MIN_COLOR_TEMP, DEFAULT_MIN_COLOR_TEMP, int_between(1000, 10000)),
+    (CONF_MAX_COLOR_TEMP, DEFAULT_MAX_COLOR_TEMP, int_between(1000, 10000)),
+    (CONF_SLEEP_BRIGHTNESS, DEFAULT_SLEEP_BRIGHTNESS, int_between(1, 100)),
+    (CONF_SLEEP_COLOR_TEMP, DEFAULT_SLEEP_COLOR_TEMP, int_between(1000, 10000)),
+    (CONF_SUNRISE_TIME, NONE_STR, str),
+    (CONF_SUNRISE_OFFSET, DEFAULT_SUNRISE_OFFSET, int),
+    (CONF_SUNSET_TIME, NONE_STR, str),
+    (CONF_SUNSET_OFFSET, DEFAULT_SUNSET_OFFSET, int),
+    (CONF_ONLY_ONCE, DEFAULT_ONLY_ONCE, bool),
+    (CONF_TAKE_OVER_CONTROL, DEFAULT_TAKE_OVER_CONTROL, bool),
+    (CONF_DETECT_NON_HA_CHANGES, DEFAULT_DETECT_NON_HA_CHANGES, bool),
+    (CONF_SEPARATE_TURN_ON_COMMANDS, DEFAULT_SEPARATE_TURN_ON_COMMANDS, bool),
+]
+
+
+def timedelta_as_int(value):
+    """Convert a `datetime.timedelta` object to an integer.
+
+    This integer can be serialized to json but a timedelta cannot.
+    """
+    return value.total_seconds()
+
+
+# conf_option: (validator, coerce) tuples
+# these validators cannot be serialized but can be serialized when coerced by coerce.
+EXTRA_VALIDATION = {
+    CONF_INTERVAL: (cv.time_period, timedelta_as_int),
+    CONF_SUNRISE_OFFSET: (cv.time_period, timedelta_as_int),
+    CONF_SUNRISE_TIME: (cv.time, str),
+    CONF_SUNSET_OFFSET: (cv.time_period, timedelta_as_int),
+    CONF_SUNSET_TIME: (cv.time, str),
+}
+
+
+def maybe_coerce(key, validation):
+    """Coerce the validation into a json serializable type."""
+    validation, coerce = EXTRA_VALIDATION.get(key, (validation, None))
+    if coerce is not None:
+        return vol.All(validation, vol.Coerce(coerce))
+    return validation
+
+
+def replace_none_str(value, replace_with=None):
+    """Replace "None" -> replace_with."""
+    return value if value != NONE_STR else replace_with
+
+
+_yaml_validation_tuples = [
+    (key, default, maybe_coerce(key, validation))
+    for key, default, validation in VALIDATION_TUPLES
+] + [(CONF_NAME, DEFAULT_NAME, cv.string)]
+
+_DOMAIN_SCHEMA = vol.Schema(
+    {
+        vol.Optional(key, default=replace_none_str(default, vol.UNDEFINED)): validation
+        for key, default, validation in _yaml_validation_tuples
+    }
+)

homeassistant/components/adaptive_lighting/manifest.json

@@ -0,0 +1,9 @@
+{
+  "domain": "adaptive_lighting",
+  "name": "Adaptive Lighting",
+  "documentation": "https://www.home-assistant.io/integrations/adaptive_lighting",
+  "config_flow": true,
+  "dependencies": [],
+  "codeowners": ["@basnijholt"],
+  "requirements": []
+}

homeassistant/components/adaptive_lighting/services.yaml

@@ -0,0 +1,36 @@
+apply:
+  description: Applies the current Adaptive Lighting settings to lights.
+  fields:
+    entity_id:
+      description: entity_id of the Adaptive Lighting switch.
+      example: switch.adaptive_lighting_default
+    lights:
+      description: entity_id(s) of lights.
+      example: light.bedroom_ceiling
+    transition:
+      description: Transition of the lights.
+      example: 10
+    adapt_brightness:
+      description: "Adapt the 'brightness', default: true"
+      example: true
+    adapt_color:
+      description: "Adapt the color_temp/color_rgb, default: true"
+      example: true
+    prefer_rgb_color:
+      description: "Prefer to use color_rgb over color_temp if possible, default: false"
+      example: false
+    turn_on_lights:
+      description: "Turn on the lights that are off, default: false"
+      example: false
+set_manual_control:
+  description: Mark whether a light is 'manually controlled'.
+  fields:
+    entity_id:
+      description: entity_id of the Adaptive Lighting switch.
+      example: switch.adaptive_lighting_default
+    manual_control:
+      description: "Whether to add ('true') or remove ('false') the light from the 'manual_control' list, default: true"
+      example: true
+    lights:
+      description: entity_id(s) of lights, if not specified, all lights in the switch are selected.
+      example: light.bedroom_ceiling