select.py

Go to the documentation of this file.

"""Support for OpenTherm Gateway select entities."""
 
from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from enum import IntEnum, StrEnum
from functools import partial
 
from pyotgw.vars import (
    OTGW_GPIO_A,
    OTGW_GPIO_B,
    OTGW_LED_A,
    OTGW_LED_B,
    OTGW_LED_C,
    OTGW_LED_D,
    OTGW_LED_E,
    OTGW_LED_F,
)
 
from homeassistant.components.select import SelectEntity, SelectEntityDescription
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_ID, EntityCategory
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import OpenThermGatewayHub
from .const import (
    DATA_GATEWAYS,
    DATA_OPENTHERM_GW,
    GATEWAY_DEVICE_DESCRIPTION,
    OpenThermDataSource,
)
from .entity import OpenThermEntityDescription, OpenThermStatusEntity
 
 
class OpenThermSelectGPIOMode(StrEnum):
    """OpenTherm Gateway GPIO modes."""
 
    INPUT = "input"
    GROUND = "ground"
    VCC = "vcc"
    LED_E = "led_e"
    LED_F = "led_f"
    HOME = "home"
    AWAY = "away"
    DS1820 = "ds1820"
    DHW_BLOCK = "dhw_block"
 
 
class OpenThermSelectLEDMode(StrEnum):
    """OpenThermGateway LED modes."""
 
    RX_ANY = "receive_any"
    TX_ANY = "transmit_any"
    THERMOSTAT_TRAFFIC = "thermostat_traffic"
    BOILER_TRAFFIC = "boiler_traffic"
    SETPOINT_OVERRIDE_ACTIVE = "setpoint_override_active"
    FLAME_ON = "flame_on"
    CENTRAL_HEATING_ON = "central_heating_on"
    HOT_WATER_ON = "hot_water_on"
    COMFORT_MODE_ON = "comfort_mode_on"
    TX_ERROR_DETECTED = "transmit_error_detected"
    BOILER_MAINTENANCE_REQUIRED = "boiler_maintenance_required"
    RAISED_POWER_MODE_ACTIVE = "raised_power_mode_active"
 
 
class PyotgwGPIOMode(IntEnum):
    """pyotgw GPIO modes."""
 
    INPUT = 0
    GROUND = 1
    VCC = 2
    LED_E = 3
    LED_F = 4
    HOME = 5
    AWAY = 6
    DS1820 = 7
    DHW_BLOCK = 8
 
 
class PyotgwLEDMode(StrEnum):
    """pyotgw LED modes."""
 
    RX_ANY = "R"
    TX_ANY = "X"
    THERMOSTAT_TRAFFIC = "T"
    BOILER_TRAFFIC = "B"
    SETPOINT_OVERRIDE_ACTIVE = "O"
    FLAME_ON = "F"
    CENTRAL_HEATING_ON = "H"
    HOT_WATER_ON = "W"
    COMFORT_MODE_ON = "C"
    TX_ERROR_DETECTED = "E"
    BOILER_MAINTENANCE_REQUIRED = "M"
    RAISED_POWER_MODE_ACTIVE = "P"
 
 
def pyotgw_led_mode_to_ha_led_mode(
    pyotgw_led_mode: PyotgwLEDMode,
) -> OpenThermSelectLEDMode | None:
    """Convert pyotgw LED mode to Home Assistant LED mode."""
    return (
        OpenThermSelectLEDMode[PyotgwLEDMode(pyotgw_led_mode).name]
        if pyotgw_led_mode in PyotgwLEDMode
        else None
    )
 
 
async def set_gpio_mode(
    gpio_id: str, gw_hub: OpenThermGatewayHub, mode: str
) -> OpenThermSelectGPIOMode | None:
    """Set gpio mode, return selected option or None."""
    value = await gw_hub.gateway.set_gpio_mode(
        gpio_id, PyotgwGPIOMode[OpenThermSelectGPIOMode(mode).name]
    )
    return (
        OpenThermSelectGPIOMode[PyotgwGPIOMode(value).name]
        if value in PyotgwGPIOMode
        else None
    )
 
 
async def set_led_mode(
    led_id: str, gw_hub: OpenThermGatewayHub, mode: str
) -> OpenThermSelectLEDMode | None:
    """Set gpio mode, return selected option or None."""
    value = await gw_hub.gateway.set_led_mode(
        led_id, PyotgwLEDMode[OpenThermSelectLEDMode(mode).name]
    )
    return (
        OpenThermSelectLEDMode[PyotgwLEDMode(value).name]
        if value in PyotgwLEDMode
        else None
    )
 
 
@dataclass(frozen=True, kw_only=True)
class OpenThermSelectEntityDescription(
    OpenThermEntityDescription, SelectEntityDescription
):
    """Describes an opentherm_gw select entity."""
 
    select_action: Callable[[OpenThermGatewayHub, str], Awaitable]
    convert_pyotgw_state_to_ha_state: Callable
 
 
SELECT_DESCRIPTIONS: tuple[OpenThermSelectEntityDescription, ...] = (
    OpenThermSelectEntityDescription(
        key=OTGW_GPIO_A,
        translation_key="gpio_mode_n",
        translation_placeholders={"gpio_id": "A"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=[
            mode
            for mode in OpenThermSelectGPIOMode
            if mode != OpenThermSelectGPIOMode.DS1820
        ],
        select_action=partial(set_gpio_mode, "A"),
        convert_pyotgw_state_to_ha_state=(
            lambda state: OpenThermSelectGPIOMode[PyotgwGPIOMode(state).name]
            if state in PyotgwGPIOMode
            else None
        ),
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_GPIO_B,
        translation_key="gpio_mode_n",
        translation_placeholders={"gpio_id": "B"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectGPIOMode),
        select_action=partial(set_gpio_mode, "B"),
        convert_pyotgw_state_to_ha_state=(
            lambda state: OpenThermSelectGPIOMode[PyotgwGPIOMode(state).name]
            if state in PyotgwGPIOMode
            else None
        ),
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_LED_A,
        translation_key="led_mode_n",
        translation_placeholders={"led_id": "A"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectLEDMode),
        select_action=partial(set_led_mode, "A"),
        convert_pyotgw_state_to_ha_state=pyotgw_led_mode_to_ha_led_mode,
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_LED_B,
        translation_key="led_mode_n",
        translation_placeholders={"led_id": "B"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectLEDMode),
        select_action=partial(set_led_mode, "B"),
        convert_pyotgw_state_to_ha_state=pyotgw_led_mode_to_ha_led_mode,
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_LED_C,
        translation_key="led_mode_n",
        translation_placeholders={"led_id": "C"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectLEDMode),
        select_action=partial(set_led_mode, "C"),
        convert_pyotgw_state_to_ha_state=pyotgw_led_mode_to_ha_led_mode,
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_LED_D,
        translation_key="led_mode_n",
        translation_placeholders={"led_id": "D"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectLEDMode),
        select_action=partial(set_led_mode, "D"),
        convert_pyotgw_state_to_ha_state=pyotgw_led_mode_to_ha_led_mode,
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_LED_E,
        translation_key="led_mode_n",
        translation_placeholders={"led_id": "E"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectLEDMode),
        select_action=partial(set_led_mode, "E"),
        convert_pyotgw_state_to_ha_state=pyotgw_led_mode_to_ha_led_mode,
    ),
    OpenThermSelectEntityDescription(
        key=OTGW_LED_F,
        translation_key="led_mode_n",
        translation_placeholders={"led_id": "F"},
        device_description=GATEWAY_DEVICE_DESCRIPTION,
        options=list(OpenThermSelectLEDMode),
        select_action=partial(set_led_mode, "F"),
        convert_pyotgw_state_to_ha_state=pyotgw_led_mode_to_ha_led_mode,
    ),
)
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: ConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up the OpenTherm Gateway select entities."""
    gw_hub = hass.data[DATA_OPENTHERM_GW][DATA_GATEWAYS][config_entry.data[CONF_ID]]
 
    async_add_entities(
        OpenThermSelect(gw_hub, description) for description in SELECT_DESCRIPTIONS
    )
 
 
class OpenThermSelect(OpenThermStatusEntity, SelectEntity):
    """Represent an OpenTherm Gateway select."""
 
    _attr_current_option = None
    _attr_entity_category = EntityCategory.CONFIG
    entity_description: OpenThermSelectEntityDescription
 
    async def async_select_option(self, option: str) -> None:
        """Change the selected option."""
        new_option = await self.entity_descriptionentity_description.select_action(self._gateway_gateway, option)
        if new_option is not None:
            self._attr_current_option_attr_current_option = new_option
            self.async_write_ha_stateasync_write_ha_state()
 
    @callback
    def receive_report(self, status: dict[OpenThermDataSource, dict]) -> None:
        """Handle status updates from the component."""
        state = status[self.entity_descriptionentity_description.device_description.data_source].get(
            self.entity_descriptionentity_description.key
        )
        self._attr_current_option_attr_current_option = (
            self.entity_descriptionentity_description.convert_pyotgw_state_to_ha_state(state)
        )
        self.async_write_ha_stateasync_write_ha_state()