switch.py

Go to the documentation of this file.

"""Support for TechnoVE switches."""
 
from __future__ import annotations
 
from collections.abc import Callable, Coroutine
from dataclasses import dataclass
from typing import Any
 
from technove import Station as TechnoVEStation
 
from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
from homeassistant.const import EntityCategory
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import TechnoVEConfigEntry
from .const import DOMAIN
from .coordinator import TechnoVEDataUpdateCoordinator
from .entity import TechnoVEEntity
from .helpers import technove_exception_handler
 
 
async def _set_charging_enabled(
    coordinator: TechnoVEDataUpdateCoordinator, enabled: bool
) -> None:
    if coordinator.data.info.auto_charge:
        raise ServiceValidationError(
            translation_domain=DOMAIN,
            translation_key="set_charging_enabled_on_auto_charge",
        )
    await coordinator.technove.set_charging_enabled(enabled=enabled)
    coordinator.data.info.is_session_active = enabled
    coordinator.async_set_updated_data(coordinator.data)
 
 
async def _enable_charging(coordinator: TechnoVEDataUpdateCoordinator) -> None:
    await _set_charging_enabled(coordinator, True)
 
 
async def _disable_charging(coordinator: TechnoVEDataUpdateCoordinator) -> None:
    await _set_charging_enabled(coordinator, False)
 
 
async def _set_auto_charge(
    coordinator: TechnoVEDataUpdateCoordinator, enabled: bool
) -> None:
    await coordinator.technove.set_auto_charge(enabled=enabled)
 
 
@dataclass(frozen=True, kw_only=True)
class TechnoVESwitchDescription(SwitchEntityDescription):
    """Describes TechnoVE binary sensor entity."""
 
    is_on_fn: Callable[[TechnoVEStation], bool]
    turn_on_fn: Callable[[TechnoVEDataUpdateCoordinator], Coroutine[Any, Any, None]]
    turn_off_fn: Callable[[TechnoVEDataUpdateCoordinator], Coroutine[Any, Any, None]]
 
 
SWITCHES = [
    TechnoVESwitchDescription(
        key="auto_charge",
        translation_key="auto_charge",
        entity_category=EntityCategory.CONFIG,
        is_on_fn=lambda station: station.info.auto_charge,
        turn_on_fn=lambda coordinator: _set_auto_charge(coordinator, True),
        turn_off_fn=lambda coordinator: _set_auto_charge(coordinator, False),
    ),
    TechnoVESwitchDescription(
        key="session_active",
        translation_key="session_active",
        entity_category=EntityCategory.CONFIG,
        is_on_fn=lambda station: station.info.is_session_active,
        turn_on_fn=_enable_charging,
        turn_off_fn=_disable_charging,
    ),
]
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    entry: TechnoVEConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up TechnoVE switch based on a config entry."""
 
    async_add_entities(
        TechnoVESwitchEntity(entry.runtime_data, description)
        for description in SWITCHES
    )
 
 
class TechnoVESwitchEntity(TechnoVEEntity, SwitchEntity):
    """Defines a TechnoVE switch entity."""
 
    entity_description: TechnoVESwitchDescription
 
    def __init__(
        self,
        coordinator: TechnoVEDataUpdateCoordinator,
        description: TechnoVESwitchDescription,
    ) -> None:
        """Initialize a TechnoVE switch entity."""
        self.entity_descriptionentity_description = description
        super().__init__(coordinator, description.key)
 
    @property
    def is_on(self) -> bool:
        """Return the state of the TechnoVE switch."""
 
        return self.entity_descriptionentity_description.is_on_fn(self.coordinator.data)
 
    @technove_exception_handler
    async def async_turn_on(self, **kwargs: Any) -> None:
        """Turn on the TechnoVE switch."""
        await self.entity_descriptionentity_description.turn_on_fn(self.coordinator)
 
    @technove_exception_handler
    async def async_turn_off(self, **kwargs: Any) -> None:
        """Turn off the TechnoVE switch."""
        await self.entity_descriptionentity_description.turn_off_fn(self.coordinator)