FR: Using Home Assistant Entities (select and number) for Room Configuration

[Julien-Decoen]

Hi @jseidl,

Once again, thank you for your great work on hass-magic_areas! While working on the project, I had an idea regarding the room configuration method.

Currently, you are using config_flow to configure devices, which works well. However, I was wondering what your thoughts would be on shifting to using Home Assistant entities like Select Entity or Number Entity for configuring rooms. This could offer more flexibility and allow users to configure rooms more dynamically through the Home Assistant UI, while seamlessly integrating with other features.

Additionally, the select and number entities could have a device entity_category set to config, as mentioned on this page.

Thanks again for your great work, and I'd love to hear your thoughts on this!

Lou juicy

[jseidl]

Hey @Julien-Decoen, thanks for the FR! In fact the control switches were moved off the config into these switches with that in mind. I've opened a PR #415 to move those into the CONFIG category.

Most of the remaining settings are required during load time, but I can look into the feasibility of converting into an entity.

Which ones do you think are good candidates? Think of ones that would make sense to change the config during runtime.

[Julien-Decoen]

Hi @jseidl,

It's already great to use this category for the switches.

In my case, I was mainly thinking about the new Illuminance threshold feature. It would allow changing the value without having to go through the multiple clicks of the config flow, making adjustments quicker and more flexible.

[Julien-Decoen]

On my fork, I’m using something like this on my select.py file :

import logging

from custom_components.magic_areas.const import (
    ADAPTIVE_LIGHTING_OPTION,
    CONF_FEATURE_ADAPTIVE_LIGHTING,
    OPTIONS_ADAPTIVE_LIGHTING_RANGE,
    OPTIONS_MEDIUM,
    SNAPSHOT_SCENE_OPTION,
)
from homeassistant.components.scene import DOMAIN as SCENE_DOMAIN
from homeassistant.components.select import DOMAIN as SELECT_DOMAIN, SelectEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import EntityCategory
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback

from .add_entities_when_ready import add_entities_when_ready
from .base.entities import MagicEntity
from .base.magic import MagicArea
from .const import CONF_FEATURE_LIGHT_GROUPS, META_AREAS, MagicAreasFeatureInfo

_LOGGER = logging.getLogger(__name__)


async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: ConfigEntry,
    async_add_entities: AddEntitiesCallback,
):
    """Set up the Area config entry."""

    add_entities_when_ready(hass, async_add_entities, config_entry, add_selects)


def add_selects(area: MagicArea, async_add_entities: AddEntitiesCallback):
    """Add all the switch entities for all features that have one."""

    select_entities = []

    if area.name not in META_AREAS:
        _LOGGER.debug("%s: Creating select entities.", area.name)

        # Check if there are any scenes

        if area.has_feature(CONF_FEATURE_LIGHT_GROUPS) and area.has_feature(
            CONF_FEATURE_ADAPTIVE_LIGHTING
        ):
            select_entities.append(SelectRange(area))

            _LOGGER.debug("Creating Area scene select for area %s", area.name)
            select_entities.append(SceneMorning(area, "morning"))
            select_entities.append(SceneDaytime(area, "daytime"))
            select_entities.append(SceneEvening(area, "evening"))
            select_entities.append(SceneNight(area, "night"))

    if select_entities:
        async_add_entities(select_entities)


class AdaptiveLightingSceneMorning(MagicAreasFeatureInfo):
    """Adaptive lighting scene morning."""

    id = "adaptive_lighting"
    translation_keys = {SELECT_DOMAIN: "scene_morning"}
    icons = {SELECT_DOMAIN: "mdi:weather-sunset-up"}


class AdaptiveLightingSceneDaytime(MagicAreasFeatureInfo):
    """Adaptive lighting scene daytime."""

    id = "adaptive_lighting"
    translation_keys = {SELECT_DOMAIN: "scene_daytime"}
    icons = {SELECT_DOMAIN: "mdi:weather-sunny"}


class AdaptiveLightingSceneEvening(MagicAreasFeatureInfo):
    """Adaptive lighting scene evening."""

    id = "adaptive_lighting"
    translation_keys = {SELECT_DOMAIN: "scene_evening"}
    icons = {SELECT_DOMAIN: "mdi:weather-sunset-down"}


class AdaptiveLightingSceneNight(MagicAreasFeatureInfo):
    """Adaptive lighting scene night."""

    id = "adaptive_lighting"
    translation_keys = {SELECT_DOMAIN: "scene_night"}
    icons = {SELECT_DOMAIN: "mdi:weather-night"}


class AdaptiveLightingRange(MagicAreasFeatureInfo):
    """Adaptive lighting scene night."""

    id = "adaptive_lighting"
    translation_keys = {SELECT_DOMAIN: "adaptive_lighting_range"}
    icons = {SELECT_DOMAIN: "mdi:square-wave"}


class SelectBase(MagicEntity, SelectEntity):
    """The base class for all the switches."""

    def __init__(self, area: MagicArea) -> None:
        """Initialize the base switch bits, basic just a mixin for the two types."""
        MagicEntity.__init__(self, area, domain=SELECT_DOMAIN)
        SelectEntity.__init__(self)
        self._attr_current_option = None

    @property
    def entity_category(self) -> str:
        """The entity category."""
        return EntityCategory.CONFIG

    async def async_added_to_hass(self) -> None:
        """Call when entity about to be added to hass."""
        await super().async_added_to_hass()

        # Restore state
        last_state = await self.async_get_last_state()
        if last_state and last_state.state != "unknown":
            self._attr_current_option = last_state.state
            self._attr_extra_state_attributes = dict(last_state.attributes)

        self.async_write_ha_state()
        self.schedule_update_ha_state()

    async def async_select_option(self, option: str) -> None:
        """Change the selected option."""
        self._attr_current_option = option
        self.schedule_update_ha_state()


class SceneTimeOfTheDay(SelectBase):
    """Select for time of the day."""

    def __init__(self, area, tod):
        """Initialize the Select component."""

        SelectBase.__init__(self, area)
        self.tod = tod
        self._attr_current_option = ADAPTIVE_LIGHTING_OPTION
        self._attr_options = []

    async def async_added_to_hass(self) -> None:
        """Call when entity about to be added to hass."""
        await super().async_added_to_hass()

        await self._update_options()

    async def _update_options(self):
        """Initialize the Select component."""

        area_scenes = [ADAPTIVE_LIGHTING_OPTION, SNAPSHOT_SCENE_OPTION]

        snapshot_scene = self.hass.states.get(f"{SCENE_DOMAIN}.{self.area.slug}_{self.tod}_snapshot_scene")
        if snapshot_scene is not None:
            area_scenes.append(SNAPSHOT_SCENE_OPTION)

        if self.area.has_entities(SCENE_DOMAIN):
            for entity in self.area.entities[SCENE_DOMAIN]:
                area_scenes.append(entity["friendly_name"])

        self._attr_options = area_scenes

        self.async_write_ha_state()


class SceneMorning(SceneTimeOfTheDay):
    """Select for morning time."""

    feature_info = AdaptiveLightingSceneMorning()


class SceneDaytime(SceneTimeOfTheDay):
    """Select for daytime time."""

    feature_info = AdaptiveLightingSceneDaytime()


class SceneEvening(SceneTimeOfTheDay):
    """Select for evening time."""

    feature_info = AdaptiveLightingSceneEvening()


class SceneNight(SceneTimeOfTheDay):
    """Select for night time."""

    feature_info = AdaptiveLightingSceneNight()


class SelectRange(SelectBase):
    """Select for adaptive lighting range."""

    feature_info = AdaptiveLightingRange()

    def __init__(self, area):
        """Initialize the adaptive lighting range select."""

        super().__init__(area)
        self._attr_options = list(OPTIONS_ADAPTIVE_LIGHTING_RANGE.keys())
        self._attr_current_option = OPTIONS_MEDIUM