Chanes from first HA Core PR

Author: rikroe

custom_components/eurotronic_cometblue/__init__.py

@@ -8,7 +8,7 @@
 from bleak.exc import BleakError
 from eurotronic_cometblue_ha import AsyncCometBlue
 
-from homeassistant.components import bluetooth
+from homeassistant.components.bluetooth import async_ble_device_from_address
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ADDRESS, CONF_PIN, Platform
 from homeassistant.core import (
@@ -18,13 +18,17 @@
     SupportsResponse,
     callback,
 )
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv, service
-from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    entity_registry as er,
+    service,
+)
 from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_ALL_DAYS, DOMAIN
-from .coordinator import CometBlueDataUpdateCoordinator
+from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
 from .entity import CometBlueBluetoothEntity
 from .utils import (
     SERVICE_DATETIME_SCHEMA,
@@ -40,8 +44,6 @@
 ]
 LOGGER = logging.getLogger(__name__)
 
-type CometBlueConfigEntry = ConfigEntry[CometBlueDataUpdateCoordinator]
-
 
 @callback
 def _async_migrate_options_if_missing(hass: HomeAssistant, entry: ConfigEntry) -> None:
@@ -103,10 +105,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: CometBlueConfigEntry) ->
 
     await _async_migrate_entries(hass, entry)
 
-
     address = entry.data[CONF_ADDRESS]
 
-    ble_device = bluetooth.async_ble_device_from_address(hass, entry.data[CONF_ADDRESS])
+    ble_device = async_ble_device_from_address(hass, entry.data[CONF_ADDRESS])
 
     if not ble_device:
         raise ConfigEntryNotReady(
@@ -120,23 +121,33 @@ async def async_setup_entry(hass: HomeAssistant, entry: CometBlueConfigEntry) ->
     try:
         async with cometblue_device:
             ble_device_info = await cometblue_device.get_device_info_async()
-            device_info = DeviceInfo(
-                identifiers={(DOMAIN, address)},
-                name=f"{ble_device_info['model']} {cometblue_device.device.address}",
-                sw_version=ble_device_info["version"],
-                manufacturer=ble_device_info["manufacturer"],
-                model=ble_device_info["model"],
-            )
+            try:
+                # Device only returns battery level if PIN is correct
+                await cometblue_device.get_battery_async()
+            except TimeoutError as ex:
+                # This likely means PIN was incorrect on Linux and ESPHome backends
+                raise ConfigEntryError(
+                    "Failed to read battery level, likely due to incorrect PIN"
+                ) from ex
     except BleakError as ex:
         raise ConfigEntryNotReady(
             f"Failed to get device info from '{cometblue_device.device.address}'"
         ) from ex
 
+    device_registry = dr.async_get(hass)
+    device_registry.async_get_or_create(
+        config_entry_id=entry.entry_id,
+        identifiers={(DOMAIN, address)},
+        name=f"{ble_device_info['model']} {cometblue_device.device.address}",
+        manufacturer=ble_device_info["manufacturer"],
+        model=ble_device_info["model"],
+        sw_version=ble_device_info["version"],
+    )
+
     coordinator = CometBlueDataUpdateCoordinator(
         hass,
         entry,
         cometblue_device,
-        device_info,
     )
     await coordinator.async_config_entry_first_refresh()
     entry.runtime_data = coordinator
@@ -155,19 +166,17 @@ async def set_datetime(
         """Service call to update the datetime on the device."""
         target_datetime = service_call.data.get("datetime") or datetime.now()
         await entity.coordinator.send_command(
-            "set_datetime_async",
+            entity.coordinator.device.set_datetime_async,
             {"date": target_datetime},
-            service_call.service,
         )
 
     async def get_schedule(
         entity: CometBlueBluetoothEntity, service_call: ServiceCall
     ) -> ServiceResponse:
         """Service call to retrieve the schedule from the device."""
         return await entity.coordinator.send_command(
-            "get_multiple_async",
+            entity.coordinator.device.get_multiple_async,
             {"values": ["weekdays"]},
-            service_call.service,
         )
 
     async def set_schedule(
@@ -191,9 +200,8 @@ async def set_schedule(
             if sched is not None and day in CONF_ALL_DAYS
         }
         await entity.coordinator.send_command(
-            "set_weekdays_async",
+            entity.coordinator.device.set_weekdays_async,
             {"values": values},
-            service_call.service,
         )
 
     async def set_holiday(
@@ -217,7 +225,7 @@ async def set_holiday(
             entity.coordinator.device.device.address,
         )
         await entity.coordinator.send_command(
-            "set_holiday_async",
+            entity.coordinator.device.set_holiday_async,
             {
                 "number": 1,
                 "values": {
@@ -226,7 +234,6 @@ async def set_holiday(
                     "temperature": service_call.data["temperature"],
                 },
             },
-            service_call.service,
         )
 
     service.async_register_platform_entity_service(
@@ -271,8 +278,4 @@ async def set_holiday(
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        coordinator: CometBlueDataUpdateCoordinator = entry.runtime_data
-        await coordinator.async_shutdown()
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

custom_components/eurotronic_cometblue/climate.py

@@ -9,20 +9,20 @@
     ATTR_TARGET_TEMP_HIGH,
     ATTR_TARGET_TEMP_LOW,
     PRESET_AWAY,
+    PRESET_BOOST,
     PRESET_COMFORT,
     PRESET_ECO,
     PRESET_NONE,
     ClimateEntity,
     ClimateEntityFeature,
-    HVACAction,
     HVACMode,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, PRECISION_HALVES, UnitOfTemperature
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import CometBlueDataUpdateCoordinator
+from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
 from .entity import CometBlueBluetoothEntity
 
 LOGGER = logging.getLogger(__name__)
@@ -31,17 +31,15 @@
 MIN_TEMP = 7.5
 MAX_TEMP = 28.5
 
-DEFAULT_PRESETS = {PRESET_COMFORT, PRESET_ECO}
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: CometBlueConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the client entities."""
 
-    coordinator: CometBlueDataUpdateCoordinator = entry.runtime_data
+    coordinator = entry.runtime_data
     async_add_entities([CometBlueClimateEntity(coordinator)])
 
 
@@ -53,10 +51,11 @@ class CometBlueClimateEntity(CometBlueBluetoothEntity, ClimateEntity):
     _attr_name = None
     _attr_hvac_modes = [HVACMode.AUTO, HVACMode.HEAT, HVACMode.OFF]
     _attr_preset_modes = [
-        PRESET_NONE,
+        PRESET_COMFORT,
         PRESET_ECO,
+        PRESET_BOOST,
         PRESET_AWAY,
-        PRESET_COMFORT,
+        PRESET_NONE,
     ]
     _attr_supported_features: ClimateEntityFeature = (
         ClimateEntityFeature.TARGET_TEMPERATURE
@@ -72,27 +71,27 @@ def __init__(self, coordinator: CometBlueDataUpdateCoordinator) -> None:
         """Initialize CometBlueClimateEntity."""
 
         super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.address}-climate"
+        self._attr_unique_id = coordinator.address
 
     @property
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
-        return self.coordinator.data["currentTemp"]
+        return self.coordinator.data.temperatures["currentTemp"]
 
     @property
     def target_temperature(self) -> float | None:
         """Return the temperature currently set to be reached."""
-        return self.coordinator.data["manualTemp"]
+        return self.coordinator.data.temperatures["manualTemp"]
 
     @property
     def target_temperature_high(self) -> float | None:
         """Return the upper bound target temperature."""
-        return self.coordinator.data["targetTempHigh"]
+        return self.coordinator.data.temperatures["targetTempHigh"]
 
     @property
     def target_temperature_low(self) -> float | None:
         """Return the lower bound target temperature."""
-        return self.coordinator.data["targetTempLow"]
+        return self.coordinator.data.temperatures["targetTempLow"]
 
     @property
     def hvac_mode(self) -> HVACMode | None:
@@ -103,76 +102,58 @@ def hvac_mode(self) -> HVACMode | None:
             return HVACMode.HEAT
         return HVACMode.AUTO
 
-    @property
-    def hvac_action(self) -> HVACAction | None:
-        """Return the current running hvac action if supported."""
-
-        if self.target_temperature == MIN_TEMP:
-            return HVACAction.OFF
-        if (self.target_temperature or 0.0) > (
-            self.target_temperature_low or 0.0
-        ) or self.target_temperature == MAX_TEMP:
-            return HVACAction.HEATING
-        return HVACAction.IDLE
-
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode, e.g., home, away, temp."""
         # presets have an order in which they are displayed on TRV:
-        # away, comfort, eco, none (manual)
+        # away, boost, comfort, eco, none (manual)
         if (
-            self.coordinator.data["holiday"].get("start") is None
-            and self.coordinator.data["holiday"].get("end") is not None
+            self.coordinator.data.holiday.get("start") is None
+            and self.coordinator.data.holiday.get("end") is not None
             and self.target_temperature
-            == self.coordinator.data["holiday"].get("temperature")
+            == self.coordinator.data.holiday.get("temperature")
         ):
             return PRESET_AWAY
+        if self.target_temperature == MAX_TEMP:
+            return PRESET_BOOST
         if self.target_temperature == self.target_temperature_high:
             return PRESET_COMFORT
         if self.target_temperature == self.target_temperature_low:
             return PRESET_ECO
         return PRESET_NONE
 
-    @property
-    def preset_modes(self) -> list[str] | None:
-        """Return a list of available preset modes.
-
-        Will only show presets that are supported by the device.
-        """
-        if self.preset_mode:
-            return list(DEFAULT_PRESETS | {self.preset_mode})
-        return list(DEFAULT_PRESETS)
-
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperatures."""
 
         if self.preset_mode == PRESET_AWAY:
-            raise ValueError(
+            raise ServiceValidationError(
                 "Cannot adjust TRV remotely, manually disable 'holiday' mode on TRV first"
             )
 
         await self.coordinator.send_command(
-            "set_temperature_async",
+            self.coordinator.device.set_temperature_async,
             {
                 "values": {
                     # manual temperature always needs to be set, otherwise TRV will turn OFF
                     "manualTemp": kwargs.get(ATTR_TEMPERATURE)
                     or self.target_temperature,
+                    # other temperatures can be left unchanged by setting them to None
                     "targetTempLow": kwargs.get(ATTR_TARGET_TEMP_LOW),
                     "targetTempHigh": kwargs.get(ATTR_TARGET_TEMP_HIGH),
                 }
             },
-            self.entity_id,
         )
         await self.coordinator.async_request_refresh()
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set new target preset mode."""
 
         if self.preset_modes and preset_mode not in self.preset_modes:
-            raise ValueError(f"Unsupported preset_mode '{preset_mode}'")
+            raise ServiceValidationError(f"Unsupported preset_mode '{preset_mode}'")
         if preset_mode in [PRESET_NONE, PRESET_AWAY]:
-            raise ValueError(f"Unable to set preset '{preset_mode}', display only.")
+            raise ServiceValidationError(
+                f"Unable to set preset '{preset_mode}', display only."
+            )
         if preset_mode == PRESET_ECO:
             return await self.async_set_temperature(
                 temperature=self.target_temperature_low
@@ -181,6 +162,8 @@ async def async_set_preset_mode(self, preset_mode: str) -> None:
             return await self.async_set_temperature(
                 temperature=self.target_temperature_high
             )
+        if preset_mode == PRESET_BOOST:
+            return await self.async_set_temperature(temperature=MAX_TEMP)
         return None
 
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
@@ -194,7 +177,7 @@ async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
             return await self.async_set_temperature(
                 temperature=self.target_temperature_low
             )
-        raise ValueError(f"Unknown HVAC mode '{hvac_mode}'")
+        raise ServiceValidationError(f"Unknown HVAC mode '{hvac_mode}'")
 
     async def async_turn_on(self) -> None:
         """Turn the entity on."""