climate.py

Go to the documentation of this file.

"""Support for the Hive climate devices."""
 
from datetime import timedelta
import logging
from typing import Any
 
from apyhiveapi import Hive
import voluptuous as vol
 
from homeassistant.components.climate import (
    PRESET_BOOST,
    PRESET_NONE,
    ClimateEntity,
    ClimateEntityFeature,
    HVACAction,
    HVACMode,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv, entity_platform
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import refresh_system
from .const import (
    ATTR_TIME_PERIOD,
    DOMAIN,
    SERVICE_BOOST_HEATING_OFF,
    SERVICE_BOOST_HEATING_ON,
)
from .entity import HiveEntity
 
HIVE_TO_HASS_STATE = {
    "SCHEDULE": HVACMode.AUTO,
    "MANUAL": HVACMode.HEAT,
    "OFF": HVACMode.OFF,
}
 
HASS_TO_HIVE_STATE = {
    HVACMode.AUTO: "SCHEDULE",
    HVACMode.HEAT: "MANUAL",
    HVACMode.OFF: "OFF",
}
 
HIVE_TO_HASS_HVAC_ACTION = {
    "UNKNOWN": HVACAction.OFF,
    False: HVACAction.IDLE,
    True: HVACAction.HEATING,
}
 
TEMP_UNIT = {
    "C": UnitOfTemperature.CELSIUS,
    "F": UnitOfTemperature.FAHRENHEIT,
}
PARALLEL_UPDATES = 0
SCAN_INTERVAL = timedelta(seconds=15)
_LOGGER = logging.getLogger()
 
 
async def async_setup_entry(
    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
) -> None:
    """Set up Hive thermostat based on a config entry."""
 
    hive = hass.data[DOMAIN][entry.entry_id]
    devices = hive.session.deviceList.get("climate")
    if devices:
        async_add_entities((HiveClimateEntity(hive, dev) for dev in devices), True)
 
    platform = entity_platform.async_get_current_platform()
 
    platform.async_register_entity_service(
        SERVICE_BOOST_HEATING_ON,
        {
            vol.Required(ATTR_TIME_PERIOD): vol.All(
                cv.time_period,
                cv.positive_timedelta,
                lambda td: td.total_seconds() // 60,
            ),
            vol.Optional(ATTR_TEMPERATURE, default="25.0"): vol.Coerce(float),
        },
        "async_heating_boost_on",
    )
 
    platform.async_register_entity_service(
        SERVICE_BOOST_HEATING_OFF,
        None,
        "async_heating_boost_off",
    )
 
 
class HiveClimateEntity(HiveEntity, ClimateEntity):
    """Hive Climate Device."""
 
    _attr_hvac_modes = [HVACMode.AUTO, HVACMode.HEAT, HVACMode.OFF]
    _attr_preset_modes = [PRESET_BOOST, PRESET_NONE]
    _attr_supported_features = (
        ClimateEntityFeature.TARGET_TEMPERATURE
        | ClimateEntityFeature.PRESET_MODE
        | ClimateEntityFeature.TURN_OFF
        | ClimateEntityFeature.TURN_ON
    )
    _enable_turn_on_off_backwards_compatibility = False
 
    def __init__(self, hive: Hive, hive_device: dict[str, Any]) -> None:
        """Initialize the Climate device."""
        super().__init__(hive, hive_device)
        self.thermostat_node_idthermostat_node_id = hive_device["device_id"]
        self._attr_temperature_unit_attr_temperature_unit = TEMP_UNIT[hive_device["temperatureunit"]]
 
    @refresh_system
    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
        """Set new target hvac mode."""
        new_mode = HASS_TO_HIVE_STATE[hvac_mode]
        await self.hivehive.heating.setMode(self.devicedevicedevice, new_mode)
 
    @refresh_system
    async def async_set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperature."""
        new_temperature = kwargs.get(ATTR_TEMPERATURE)
        if new_temperature is not None:
            await self.hivehive.heating.setTargetTemperature(self.devicedevicedevice, new_temperature)
 
    @refresh_system
    async def async_set_preset_mode(self, preset_mode: str) -> None:
        """Set new preset mode."""
        if preset_mode == PRESET_NONE and self.preset_modepreset_modepreset_mode == PRESET_BOOST:
            await self.hivehive.heating.setBoostOff(self.devicedevicedevice)
        elif preset_mode == PRESET_BOOST:
            curtemp = round((self.current_temperaturecurrent_temperature or 0) * 2) / 2
            temperature = curtemp + 0.5
            await self.hivehive.heating.setBoostOn(self.devicedevicedevice, 30, temperature)
 
    @refresh_system
    async def async_heating_boost_on(self, time_period, temperature):
        """Handle boost heating service call."""
        await self.hivehive.heating.setBoostOn(self.devicedevicedevice, time_period, temperature)
 
    @refresh_system
    async def async_heating_boost_off(self) -> None:
        """Handle boost heating service call."""
        await self.hivehive.heating.setBoostOff(self.devicedevicedevice)
 
    async def async_update(self) -> None:
        """Update all Node data from Hive."""
        await self.hivehive.session.updateData(self.devicedevicedevice)
        self.devicedevicedevice = await self.hivehive.heating.getClimate(self.devicedevicedevice)
        self._attr_available_attr_available = self.devicedevicedevice["deviceData"].get("online")
        if self._attr_available_attr_available:
            self._attr_hvac_mode_attr_hvac_mode = HIVE_TO_HASS_STATE.get(self.devicedevicedevice["status"]["mode"])
            self._attr_hvac_action_attr_hvac_action = HIVE_TO_HASS_HVAC_ACTION.get(
                self.devicedevicedevice["status"]["action"]
            )
            self._attr_current_temperature_attr_current_temperature = self.devicedevicedevice["status"][
                "current_temperature"
            ]
            self._attr_target_temperature_attr_target_temperature = self.devicedevicedevice["status"]["target_temperature"]
            self._attr_min_temp_attr_min_temp = self.devicedevicedevice["min_temp"]
            self._attr_max_temp_attr_max_temp = self.devicedevicedevice["max_temp"]
            if self.devicedevicedevice["status"]["boost"] == "ON":
                self._attr_preset_mode_attr_preset_mode = PRESET_BOOST
                self._attr_hvac_mode_attr_hvac_mode = HVACMode.HEAT
            else:
                self._attr_preset_mode_attr_preset_mode = PRESET_NONE