Changes from HA

* Climate, button, sensor and number integration from HA
* Migrations for number unique ids
* set_datetime service replaced with button

Author: rikroe

custom_components/eurotronic_cometblue/__init__.py

@@ -30,14 +30,11 @@
 from .const import CONF_ALL_DAYS, DOMAIN
 from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
 from .entity import CometBlueBluetoothEntity
-from .utils import (
-    SERVICE_DATETIME_SCHEMA,
-    SERVICE_HOLIDAY_SCHEMA,
-    SERVICE_SCHEDULE_SCHEMA,
-)
+from .utils import SERVICE_HOLIDAY_SCHEMA, SERVICE_SCHEDULE_SCHEMA
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS: list[Platform] = [
+    Platform.BUTTON,
     Platform.CLIMATE,
     Platform.NUMBER,
     Platform.SENSOR,
@@ -71,27 +68,33 @@ async def _async_migrate_entries(
 
     @callback
     def update_unique_id(entry: er.RegistryEntry) -> dict[str, str] | None:
+        new_unique_id = None
         if entry.domain == "climate" and entry.unique_id.endswith("-climate"):
             new_unique_id = entry.unique_id.replace("-climate", "")
+        elif entry.domain == "number" and entry.unique_id.endswith("-target_temp_low"):
+            new_unique_id = entry.unique_id.replace("-target_temp_low", "-eco_setpoint")
+        elif entry.domain == "number" and entry.unique_id.endswith("-target_temp_high"):
+            new_unique_id = entry.unique_id.replace("-target_temp_high", "-comfort_setpoint")
+        else:
+            return None
+        LOGGER.debug(
+            "Migrating entity '%s' unique_id from '%s' to '%s'",
+            entry.entity_id,
+            entry.unique_id,
+            new_unique_id,
+        )
+        if existing_entity_id := entity_registry.async_get_entity_id(
+            entry.domain, entry.platform, new_unique_id
+        ):
             LOGGER.debug(
-                "Migrating entity '%s' unique_id from '%s' to '%s'",
-                entry.entity_id,
-                entry.unique_id,
+                "Cannot migrate to unique_id '%s', already exists for '%s'",
                 new_unique_id,
+                existing_entity_id,
             )
-            if existing_entity_id := entity_registry.async_get_entity_id(
-                entry.domain, entry.platform, new_unique_id
-            ):
-                LOGGER.debug(
-                    "Cannot migrate to unique_id '%s', already exists for '%s'",
-                    new_unique_id,
-                    existing_entity_id,
-                )
-                return None
-            return {
-                "new_unique_id": new_unique_id,
-            }
-        return None
+            return None
+        return {
+            "new_unique_id": new_unique_id,
+        }
 
     await er.async_migrate_entries(hass, config_entry.entry_id, update_unique_id)
 
@@ -160,16 +163,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: CometBlueConfigEntry) ->
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Eurotronic Comet Blue entity services."""
 
-    async def set_datetime(
-        entity: CometBlueBluetoothEntity, service_call: ServiceCall
-    ) -> None:
-        """Service call to update the datetime on the device."""
-        target_datetime = service_call.data.get("datetime") or datetime.now()
-        await entity.coordinator.send_command(
-            entity.coordinator.device.set_datetime_async,
-            {"date": target_datetime},
-        )
-
     async def get_schedule(
         entity: CometBlueBluetoothEntity, service_call: ServiceCall
     ) -> ServiceResponse:
@@ -236,15 +229,6 @@ async def set_holiday(
             },
         )
 
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        "set_datetime",
-        entity_domain="climate",
-        schema=cv.make_entity_service_schema(SERVICE_DATETIME_SCHEMA),
-        supports_response=SupportsResponse.NONE,
-        func=set_datetime,
-    )
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,

custom_components/eurotronic_cometblue/button.py

@@ -0,0 +1,59 @@
+"""Comet Blue button platform."""
+
+from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util import dt as dt_util
+
+from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
+from .entity import CometBlueBluetoothEntity
+
+PARALLEL_UPDATES = 1
+
+DESCRIPTIONS = [
+    ButtonEntityDescription(
+        key="sync_time",
+        translation_key="sync_time",
+        entity_category=EntityCategory.CONFIG,
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: CometBlueConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the client entities."""
+
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        [
+            CometBlueButtonEntity(coordinator, description)
+            for description in DESCRIPTIONS
+        ]
+    )
+
+
+class CometBlueButtonEntity(CometBlueBluetoothEntity, ButtonEntity):
+    """Representation of a button."""
+
+    def __init__(
+        self,
+        coordinator: CometBlueDataUpdateCoordinator,
+        description: ButtonEntityDescription,
+    ) -> None:
+        """Initialize CometBlueButtonEntity."""
+
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.address}-{description.key}"
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        if self.entity_description.key == "sync_time":
+            await self.coordinator.send_command(
+                self.coordinator.device.set_datetime_async, {"date": dt_util.now()}
+            )

custom_components/eurotronic_cometblue/climate.py

@@ -1,8 +1,5 @@
 """Comet Blue climate integration."""
 
-from __future__ import annotations
-
-import logging
 from typing import Any
 
 from homeassistant.components.climate import (
@@ -25,8 +22,6 @@
 from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
 from .entity import CometBlueBluetoothEntity
 
-LOGGER = logging.getLogger(__name__)
-
 PARALLEL_UPDATES = 1
 MIN_TEMP = 7.5
 MAX_TEMP = 28.5
@@ -59,7 +54,6 @@ class CometBlueClimateEntity(CometBlueBluetoothEntity, ClimateEntity):
     ]
     _attr_supported_features: ClimateEntityFeature = (
         ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
         | ClimateEntityFeature.PRESET_MODE
         | ClimateEntityFeature.TURN_ON
         | ClimateEntityFeature.TURN_OFF
@@ -84,13 +78,19 @@ def target_temperature(self) -> float | None:
         return self.coordinator.data.temperatures["manualTemp"]
 
     @property
-    def target_temperature_high(self) -> float | None:
-        """Return the upper bound target temperature."""
+    def _device_comfort_setpoint(self) -> float | None:
+        """Return the comfort setpoint temperature.
+
+        Internally used for preset selection.
+        """
         return self.coordinator.data.temperatures["targetTempHigh"]
 
     @property
-    def target_temperature_low(self) -> float | None:
-        """Return the lower bound target temperature."""
+    def _device_eco_setpoint(self) -> float | None:
+        """Return the eco setpoint temperature.
+
+        Internally used for preset selection.
+        """
         return self.coordinator.data.temperatures["targetTempLow"]
 
     @property
@@ -116,9 +116,9 @@ def preset_mode(self) -> str | None:
             return PRESET_AWAY
         if self.target_temperature == MAX_TEMP:
             return PRESET_BOOST
-        if self.target_temperature == self.target_temperature_high:
+        if self.target_temperature == self._device_comfort_setpoint:
             return PRESET_COMFORT
-        if self.target_temperature == self.target_temperature_low:
+        if self.target_temperature == self._device_eco_setpoint:
             return PRESET_ECO
         return PRESET_NONE
 
@@ -156,11 +156,11 @@ async def async_set_preset_mode(self, preset_mode: str) -> None:
             )
         if preset_mode == PRESET_ECO:
             return await self.async_set_temperature(
-                temperature=self.target_temperature_low
+                temperature=self._device_eco_setpoint
             )
         if preset_mode == PRESET_COMFORT:
             return await self.async_set_temperature(
-                temperature=self.target_temperature_high
+                temperature=self._device_comfort_setpoint
             )
         if preset_mode == PRESET_BOOST:
             return await self.async_set_temperature(temperature=MAX_TEMP)
@@ -175,7 +175,7 @@ async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
             return await self.async_set_temperature(temperature=MAX_TEMP)
         if hvac_mode == HVACMode.AUTO:
             return await self.async_set_temperature(
-                temperature=self.target_temperature_low
+                temperature=self._device_eco_setpoint
             )
         raise ServiceValidationError(f"Unknown HVAC mode '{hvac_mode}'")
 

custom_components/eurotronic_cometblue/config_flow.py

@@ -1,10 +1,9 @@
 """Config flow for CometBlue."""
 
-from __future__ import annotations
-
 import logging
 from typing import Any
 
+from bleak.exc import BleakError
 from eurotronic_cometblue_ha import AsyncCometBlue
 from eurotronic_cometblue_ha.const import SERVICE
 from habluetooth import BluetoothServiceInfoBleak
@@ -87,9 +86,12 @@ async def _try_connect(self, user_input: dict[str, Any]) -> dict[str, str]:
         except TimeoutError:
             LOGGER.debug("Connection to device timed out", exc_info=True)
             return {"base": "timeout_connect"}
-        except Exception:  # noqa: BLE001
+        except BleakError:
             LOGGER.debug("Failed to connect to device", exc_info=True)
             return {"base": "cannot_connect"}
+        except Exception:  # noqa: BLE001
+            LOGGER.debug("Unknown error", exc_info=True)
+            return {"base": "unknown"}
         return {}
 
     def _create_entry(

custom_components/eurotronic_cometblue/const.py

@@ -6,8 +6,6 @@
 
 CONF_DATETIME: Final = "datetime"
 CONF_SCHEDULE: Final = "schedule"
-CONF_RETRY_COUNT: Final = "retry_count"
-
 
 CONF_MONDAY: Final = "monday"
 CONF_TUESDAY: Final = "tuesday"

custom_components/eurotronic_cometblue/coordinator.py

@@ -1,6 +1,4 @@
-"""Provides the DataUpdateCoordinator."""
-
-from __future__ import annotations
+"""Provides the DataUpdateCoordinator for Comet Blue."""
 
 import asyncio
 from collections.abc import Awaitable, Callable
@@ -54,6 +52,7 @@ def __init__(
         )
         self.device = cometblue
         self.address = cometblue.client.address
+        self.data = CometBlueCoordinatorData()
 
     async def send_command(
         self,
@@ -65,11 +64,11 @@ async def send_command(
         LOGGER.debug("Updating device %s with '%s'", self.name, payload)
         retry_count = 0
         while retry_count < MAX_RETRIES:
+            retry_count += 1
             try:
                 async with self.device:
                     return await function(**payload)
             except (InvalidByteValueError, TimeoutError, BleakError) as ex:
-                retry_count += 1
                 if retry_count >= MAX_RETRIES:
                     raise HomeAssistantError(
                         f"Error sending command to '{self.name}': {ex}"
@@ -89,17 +88,18 @@ async def send_command(
 
     async def _async_update_data(self) -> CometBlueCoordinatorData:
         """Poll the device."""
-        data: CometBlueCoordinatorData = CometBlueCoordinatorData()
+        data = CometBlueCoordinatorData()
 
         retry_count = 0
 
         while retry_count < MAX_RETRIES and not data.temperatures:
             try:
+                retry_count += 1
                 async with self.device:
                     # temperatures are required and must trigger a retry if not available
                     if not data.temperatures:
                         data.temperatures = await self.device.get_temperature_async()
-                    # holiday is optional and should not trigger a retry
+                    # holiday and battery are optional and should not trigger a retry
                     try:
                         if not data.holiday:
                             data.holiday = await self.device.get_holiday_async(1) or {}
@@ -113,7 +113,6 @@ async def _async_update_data(self) -> CometBlueCoordinatorData:
                             ex,
                         )
             except (InvalidByteValueError, TimeoutError, BleakError) as ex:
-                retry_count += 1
                 if retry_count >= MAX_RETRIES:
                     raise UpdateFailed(
                         f"Error retrieving data: {ex}", retry_after=30
@@ -132,8 +131,8 @@ async def _async_update_data(self) -> CometBlueCoordinatorData:
 
         # If one value was not retrieved correctly, keep the old value
         if not data.holiday:
-            data.holiday = self.data.holiday if self.data else {}
+            data.holiday = self.data.holiday
         if not data.battery:
-            data.battery = self.data.battery if self.data else None
+            data.battery = self.data.battery
         LOGGER.debug("Received data for %s: %s", self.name, data)
         return data

custom_components/eurotronic_cometblue/entity.py

@@ -1,16 +1,12 @@
 """Coordinator entity base class for CometBlue."""
 
-import logging
-
 from homeassistant.components import bluetooth
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import DOMAIN
 from .coordinator import CometBlueDataUpdateCoordinator
 
-LOGGER = logging.getLogger(__name__)
-
 
 class CometBlueBluetoothEntity(CoordinatorEntity[CometBlueDataUpdateCoordinator]):
     """Coordinator entity for CometBlue."""