climate.py

Go to the documentation of this file.

"""Switcher integration Climate platform."""
 
from __future__ import annotations
 
from typing import Any, cast
 
from aioswitcher.api import SwitcherApi, SwitcherBaseResponse
from aioswitcher.api.remotes import SwitcherBreezeRemote
from aioswitcher.device import (
    DeviceCategory,
    DeviceState,
    SwitcherThermostat,
    ThermostatFanLevel,
    ThermostatMode,
    ThermostatSwing,
)
 
from homeassistant.components.climate import (
    FAN_AUTO,
    FAN_HIGH,
    FAN_LOW,
    FAN_MEDIUM,
    SWING_OFF,
    SWING_VERTICAL,
    ClimateEntity,
    ClimateEntityFeature,
    HVACMode,
)
from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import SwitcherConfigEntry
from .const import SIGNAL_DEVICE_ADD
from .coordinator import SwitcherDataUpdateCoordinator
from .entity import SwitcherEntity
from .utils import get_breeze_remote_manager
 
DEVICE_MODE_TO_HA = {
    ThermostatMode.COOL: HVACMode.COOL,
    ThermostatMode.HEAT: HVACMode.HEAT,
    ThermostatMode.FAN: HVACMode.FAN_ONLY,
    ThermostatMode.DRY: HVACMode.DRY,
    ThermostatMode.AUTO: HVACMode.HEAT_COOL,
}
 
HA_TO_DEVICE_MODE = {value: key for key, value in DEVICE_MODE_TO_HA.items()}
 
DEVICE_FAN_TO_HA = {
    ThermostatFanLevel.LOW: FAN_LOW,
    ThermostatFanLevel.MEDIUM: FAN_MEDIUM,
    ThermostatFanLevel.HIGH: FAN_HIGH,
    ThermostatFanLevel.AUTO: FAN_AUTO,
}
 
HA_TO_DEVICE_FAN = {value: key for key, value in DEVICE_FAN_TO_HA.items()}
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: SwitcherConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up Switcher climate from config entry."""
 
    async def async_add_climate(coordinator: SwitcherDataUpdateCoordinator) -> None:
        """Get remote and add climate from Switcher device."""
        data = cast(SwitcherThermostat, coordinator.data)
        if coordinator.data.device_type.category == DeviceCategory.THERMOSTAT:
            remote: SwitcherBreezeRemote = await hass.async_add_executor_job(
                get_breeze_remote_manager(hass).get_remote, data.remote_id
            )
            async_add_entities([SwitcherClimateEntity(coordinator, remote)])
 
    config_entry.async_on_unload(
        async_dispatcher_connect(hass, SIGNAL_DEVICE_ADD, async_add_climate)
    )
 
 
class SwitcherClimateEntity(SwitcherEntity, ClimateEntity):
    """Representation of a Switcher climate entity."""
 
    _attr_name = None
    _enable_turn_on_off_backwards_compatibility = False
 
    def __init__(
        self, coordinator: SwitcherDataUpdateCoordinator, remote: SwitcherBreezeRemote
    ) -> None:
        """Initialize the entity."""
        super().__init__(coordinator)
        self._remote_remote = remote
 
        self._attr_unique_id_attr_unique_id = f"{coordinator.device_id}-{coordinator.mac_address}"
 
        self._attr_min_temp_attr_min_temp = remote.min_temperature
        self._attr_max_temp_attr_max_temp = remote.max_temperature
        self._attr_target_temperature_step_attr_target_temperature_step = 1
        self._attr_temperature_unit_attr_temperature_unit = UnitOfTemperature.CELSIUS
 
        self._attr_hvac_modes_attr_hvac_modes = [HVACMode.OFF]
        for mode in remote.modes_features:
            self._attr_hvac_modes_attr_hvac_modes.append(DEVICE_MODE_TO_HA[mode])
            features = remote.modes_features[mode]
 
            if features["temperature_control"]:
                self._attr_supported_features |= ClimateEntityFeature.TARGET_TEMPERATURE
 
            if features["fan_levels"]:
                self._attr_supported_features |= ClimateEntityFeature.FAN_MODE
 
            if features["swing"] and not remote.separated_swing_command:
                self._attr_supported_features |= ClimateEntityFeature.SWING_MODE
 
        # There is always support for off + minimum one other mode so no need to check
        self._attr_supported_features |= (
            ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
        )
        self._update_data_update_data(True)
 
    @callback
    def _handle_coordinator_update(self) -> None:
        """Handle updated data from the coordinator."""
        self._update_data_update_data()
        self.async_write_ha_stateasync_write_ha_state()
 
    def _update_data(self, force_update: bool = False) -> None:
        """Update data from device."""
        data = cast(SwitcherThermostat, self.coordinator.data)
        features = self._remote_remote.modes_features[data.mode]
 
        if data.target_temperature == 0 and not force_update:
            return
 
        self._attr_current_temperature_attr_current_temperature = data.temperature
        self._attr_target_temperature_attr_target_temperature = float(data.target_temperature)
 
        self._attr_hvac_mode_attr_hvac_mode = HVACMode.OFF
        if data.device_state == DeviceState.ON:
            self._attr_hvac_mode_attr_hvac_mode = DEVICE_MODE_TO_HA[data.mode]
 
        self._attr_fan_mode_attr_fan_mode = None
        self._attr_fan_modes_attr_fan_modes = []
        if features["fan_levels"]:
            self._attr_fan_modes_attr_fan_modes = [DEVICE_FAN_TO_HA[x] for x in features["fan_levels"]]
            self._attr_fan_mode_attr_fan_mode = DEVICE_FAN_TO_HA[data.fan_level]
 
        self._attr_swing_mode_attr_swing_mode = None
        self._attr_swing_modes_attr_swing_modes = []
        if features["swing"]:
            self._attr_swing_mode_attr_swing_mode = SWING_OFF
            self._attr_swing_modes_attr_swing_modes = [SWING_VERTICAL, SWING_OFF]
            if data.swing == ThermostatSwing.ON:
                self._attr_swing_mode_attr_swing_mode = SWING_VERTICAL
 
    async def _async_control_breeze_device(self, **kwargs: Any) -> None:
        """Call Switcher Control Breeze API."""
        response: SwitcherBaseResponse | None = None
        error = None
 
        try:
            async with SwitcherApi(
                self.coordinator.data.device_type,
                self.coordinator.data.ip_address,
                self.coordinator.data.device_id,
                self.coordinator.data.device_key,
            ) as swapi:
                response = await swapi.control_breeze_device(self._remote_remote, **kwargs)
        except (TimeoutError, OSError, RuntimeError) as err:
            error = repr(err)
 
        if error or not response or not response.successful:
            self.coordinator.last_update_success = False
            self.async_write_ha_stateasync_write_ha_state()
            raise HomeAssistantError(
                f"Call Breeze control for {self.name} failed, "
                f"response/error: {response or error}"
            )
 
    async def async_set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperature."""
        data = cast(SwitcherThermostat, self.coordinator.data)
        if not self._remote_remote.modes_features[data.mode]["temperature_control"]:
            raise HomeAssistantError(
                "Current mode doesn't support setting Target Temperature"
            )
 
        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
            raise ValueError("No target temperature provided")
 
        await self._async_control_breeze_device_async_control_breeze_device(target_temp=int(temperature))
 
    async def async_set_fan_mode(self, fan_mode: str) -> None:
        """Set new target fan mode."""
        data = cast(SwitcherThermostat, self.coordinator.data)
        if not self._remote_remote.modes_features[data.mode]["fan_levels"]:
            raise HomeAssistantError("Current mode doesn't support setting Fan Mode")
 
        await self._async_control_breeze_device_async_control_breeze_device(fan_level=HA_TO_DEVICE_FAN[fan_mode])
 
    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
        """Set new target operation mode."""
        if hvac_mode == hvac_mode.OFF:
            await self._async_control_breeze_device_async_control_breeze_device(state=DeviceState.OFF)
        else:
            await self._async_control_breeze_device_async_control_breeze_device(
                state=DeviceState.ON, mode=HA_TO_DEVICE_MODE[hvac_mode]
            )
 
    async def async_set_swing_mode(self, swing_mode: str) -> None:
        """Set new target swing operation."""
        data = cast(SwitcherThermostat, self.coordinator.data)
        if not self._remote_remote.modes_features[data.mode]["swing"]:
            raise HomeAssistantError("Current mode doesn't support setting Swing Mode")
 
        if swing_mode == SWING_VERTICAL:
            await self._async_control_breeze_device_async_control_breeze_device(swing=ThermostatSwing.ON)
        else:
            await self._async_control_breeze_device_async_control_breeze_device(swing=ThermostatSwing.OFF)