Discovery of Miele temperature sensors (home-assistant#144585)

Co-authored-by: Joost Lekkerkerker <[email protected]>

Author: aturri

homeassistant/components/miele/entity.py

@@ -16,6 +16,11 @@ class MieleEntity(CoordinatorEntity[MieleDataUpdateCoordinator]):
 
     _attr_has_entity_name = True
 
+    @staticmethod
+    def get_unique_id(device_id: str, description: EntityDescription) -> str:
+        """Generate a unique ID for the entity."""
+        return f"{device_id}-{description.key}"
+
     def __init__(
         self,
         coordinator: MieleDataUpdateCoordinator,
@@ -26,7 +31,7 @@ def __init__(
         super().__init__(coordinator)
         self._device_id = device_id
         self.entity_description = description
-        self._attr_unique_id = f"{device_id}-{description.key}"
+        self._attr_unique_id = MieleEntity.get_unique_id(device_id, description)
 
         device = self.device
         appliance_type = DEVICE_TYPE_TAGS.get(MieleAppliance(device.device_type))

homeassistant/components/miele/sensor.py

@@ -7,7 +7,7 @@
 import logging
 from typing import Final, cast
 
-from pymiele import MieleDevice
+from pymiele import MieleDevice, MieleTemperature
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -25,10 +25,13 @@
     UnitOfVolume,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
 from .const import (
+    DISABLED_TEMP_ENTITIES,
+    DOMAIN,
     STATE_PROGRAM_ID,
     STATE_PROGRAM_PHASE,
     STATE_STATUS_TAGS,
@@ -45,8 +48,6 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-DISABLED_TEMPERATURE = -32768
-
 DEFAULT_PLATE_COUNT = 4
 
 PLATE_COUNT = {
@@ -75,12 +76,25 @@ def _convert_duration(value_list: list[int]) -> int | None:
     return value_list[0] * 60 + value_list[1] if value_list else None
 
 
+def _convert_temperature(
+    value_list: list[MieleTemperature], index: int
+) -> float | None:
+    """Convert temperature object to readable value."""
+    if index >= len(value_list):
+        return None
+    raw_value = cast(int, value_list[index].temperature) / 100.0
+    if raw_value in DISABLED_TEMP_ENTITIES:
+        return None
+    return raw_value
+
+
 @dataclass(frozen=True, kw_only=True)
 class MieleSensorDescription(SensorEntityDescription):
     """Class describing Miele sensor entities."""
 
     value_fn: Callable[[MieleDevice], StateType]
-    zone: int = 1
+    zone: int | None = None
+    unique_id_fn: Callable[[str, MieleSensorDescription], str] | None = None
 
 
 @dataclass
@@ -404,32 +418,20 @@ class MieleSensorDefinition:
         ),
         description=MieleSensorDescription(
             key="state_temperature_1",
+            zone=1,
             device_class=SensorDeviceClass.TEMPERATURE,
             native_unit_of_measurement=UnitOfTemperature.CELSIUS,
             state_class=SensorStateClass.MEASUREMENT,
-            value_fn=lambda value: cast(int, value.state_temperatures[0].temperature)
-            / 100.0,
+            value_fn=lambda value: _convert_temperature(value.state_temperatures, 0),
         ),
     ),
     MieleSensorDefinition(
         types=(
-            MieleAppliance.TUMBLE_DRYER_SEMI_PROFESSIONAL,
-            MieleAppliance.OVEN,
-            MieleAppliance.OVEN_MICROWAVE,
-            MieleAppliance.DISH_WARMER,
-            MieleAppliance.STEAM_OVEN,
-            MieleAppliance.MICROWAVE,
-            MieleAppliance.FRIDGE,
-            MieleAppliance.FREEZER,
             MieleAppliance.FRIDGE_FREEZER,
-            MieleAppliance.STEAM_OVEN_COMBI,
             MieleAppliance.WINE_CABINET,
             MieleAppliance.WINE_CONDITIONING_UNIT,
             MieleAppliance.WINE_STORAGE_CONDITIONING_UNIT,
-            MieleAppliance.STEAM_OVEN_MICRO,
-            MieleAppliance.DIALOG_OVEN,
             MieleAppliance.WINE_CABINET_FREEZER,
-            MieleAppliance.STEAM_OVEN_MK2,
         ),
         description=MieleSensorDescription(
             key="state_temperature_2",
@@ -438,7 +440,24 @@ class MieleSensorDefinition:
             translation_key="temperature_zone_2",
             native_unit_of_measurement=UnitOfTemperature.CELSIUS,
             state_class=SensorStateClass.MEASUREMENT,
-            value_fn=lambda value: value.state_temperatures[1].temperature / 100.0,  # type: ignore [operator]
+            value_fn=lambda value: _convert_temperature(value.state_temperatures, 1),
+        ),
+    ),
+    MieleSensorDefinition(
+        types=(
+            MieleAppliance.WINE_CABINET,
+            MieleAppliance.WINE_CONDITIONING_UNIT,
+            MieleAppliance.WINE_STORAGE_CONDITIONING_UNIT,
+            MieleAppliance.WINE_CABINET_FREEZER,
+        ),
+        description=MieleSensorDescription(
+            key="state_temperature_3",
+            zone=3,
+            device_class=SensorDeviceClass.TEMPERATURE,
+            translation_key="temperature_zone_3",
+            native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+            state_class=SensorStateClass.MEASUREMENT,
+            value_fn=lambda value: _convert_temperature(value.state_temperatures, 2),
         ),
     ),
     MieleSensorDefinition(
@@ -454,11 +473,8 @@ class MieleSensorDefinition:
             device_class=SensorDeviceClass.TEMPERATURE,
             native_unit_of_measurement=UnitOfTemperature.CELSIUS,
             state_class=SensorStateClass.MEASUREMENT,
-            value_fn=(
-                lambda value: cast(
-                    int, value.state_core_target_temperature[0].temperature
-                )
-                / 100.0
+            value_fn=lambda value: _convert_temperature(
+                value.state_core_target_temperature, 0
             ),
         ),
     ),
@@ -479,9 +495,8 @@ class MieleSensorDefinition:
             device_class=SensorDeviceClass.TEMPERATURE,
             native_unit_of_measurement=UnitOfTemperature.CELSIUS,
             state_class=SensorStateClass.MEASUREMENT,
-            value_fn=(
-                lambda value: cast(int, value.state_target_temperature[0].temperature)
-                / 100.0
+            value_fn=lambda value: _convert_temperature(
+                value.state_target_temperature, 0
             ),
         ),
     ),
@@ -497,9 +512,8 @@ class MieleSensorDefinition:
             device_class=SensorDeviceClass.TEMPERATURE,
             native_unit_of_measurement=UnitOfTemperature.CELSIUS,
             state_class=SensorStateClass.MEASUREMENT,
-            value_fn=(
-                lambda value: cast(int, value.state_core_temperature[0].temperature)
-                / 100.0
+            value_fn=lambda value: _convert_temperature(
+                value.state_core_temperature, 0
             ),
         ),
     ),
@@ -518,6 +532,8 @@ class MieleSensorDefinition:
                 device_class=SensorDeviceClass.ENUM,
                 options=sorted(PlatePowerStep.keys()),
                 value_fn=lambda value: None,
+                unique_id_fn=lambda device_id,
+                description: f"{device_id}-{description.key}-{description.zone}",
             ),
         )
         for i in range(1, 7)
@@ -559,51 +575,88 @@ async def async_setup_entry(
 ) -> None:
     """Set up the sensor platform."""
     coordinator = config_entry.runtime_data
-    added_devices: set[str] = set()
+    added_devices: set[str] = set()  # device_id
+    added_entities: set[str] = set()  # unique_id
+
+    def _get_entity_class(definition: MieleSensorDefinition) -> type[MieleSensor]:
+        """Get the entity class for the sensor."""
+        return {
+            "state_status": MieleStatusSensor,
+            "state_program_id": MieleProgramIdSensor,
+            "state_program_phase": MielePhaseSensor,
+            "state_plate_step": MielePlateSensor,
+        }.get(definition.description.key, MieleSensor)
+
+    def _is_entity_registered(unique_id: str) -> bool:
+        """Check if the entity is already registered."""
+        entity_registry = er.async_get(hass)
+        return any(
+            entry.platform == DOMAIN and entry.unique_id == unique_id
+            for entry in entity_registry.entities.values()
+        )
+
+    def _is_sensor_enabled(
+        definition: MieleSensorDefinition,
+        device: MieleDevice,
+        unique_id: str,
+    ) -> bool:
+        """Check if the sensor is enabled."""
+        if (
+            definition.description.device_class == SensorDeviceClass.TEMPERATURE
+            and definition.description.value_fn(device) is None
+            and definition.description.zone != 1
+        ):
+            # all appliances supporting temperature have at least zone 1, for other zones
+            # don't create entity if API signals that datapoint is disabled, unless the sensor
+            # already appeared in the past (= it provided a valid value)
+            return _is_entity_registered(unique_id)
+        if (
+            definition.description.key == "state_plate_step"
+            and definition.description.zone is not None
+            and definition.description.zone > _get_plate_count(device.tech_type)
+        ):
+            # don't create plate entity if not expected by the appliance tech type
+            return False
+        return True
 
-    def _async_add_new_devices() -> None:
-        nonlocal added_devices
+    def _async_add_devices() -> None:
+        nonlocal added_devices, added_entities
         entities: list = []
         entity_class: type[MieleSensor]
         new_devices_set, current_devices = coordinator.async_add_devices(added_devices)
         added_devices = current_devices
 
         for device_id, device in coordinator.data.devices.items():
             for definition in SENSOR_TYPES:
-                if (
-                    device_id in new_devices_set
-                    and device.device_type in definition.types
-                ):
-                    match definition.description.key:
-                        case "state_status":
-                            entity_class = MieleStatusSensor
-                        case "state_program_id":
-                            entity_class = MieleProgramIdSensor
-                        case "state_program_phase":
-                            entity_class = MielePhaseSensor
-                        case "state_plate_step":
-                            entity_class = MielePlateSensor
-                        case _:
-                            entity_class = MieleSensor
-                    if (
-                        definition.description.device_class
-                        == SensorDeviceClass.TEMPERATURE
-                        and definition.description.value_fn(device)
-                        == DISABLED_TEMPERATURE / 100
-                    ) or (
-                        definition.description.key == "state_plate_step"
-                        and definition.description.zone
-                        > _get_plate_count(device.tech_type)
-                    ):
-                        # Don't create entity if API signals that datapoint is disabled
-                        continue
-                    entities.append(
-                        entity_class(coordinator, device_id, definition.description)
+                # device is not supported, skip
+                if device.device_type not in definition.types:
+                    continue
+
+                entity_class = _get_entity_class(definition)
+                unique_id = (
+                    definition.description.unique_id_fn(
+                        device_id, definition.description
                     )
+                    if definition.description.unique_id_fn is not None
+                    else MieleEntity.get_unique_id(device_id, definition.description)
+                )
+
+                # entity was already added, skip
+                if device_id not in new_devices_set and unique_id in added_entities:
+                    continue
+
+                # sensors is not enabled, skip
+                if not _is_sensor_enabled(definition, device, unique_id):
+                    continue
+
+                added_entities.add(unique_id)
+                entities.append(
+                    entity_class(coordinator, device_id, definition.description)
+                )
         async_add_entities(entities)
 
-    config_entry.async_on_unload(coordinator.async_add_listener(_async_add_new_devices))
-    _async_add_new_devices()
+    config_entry.async_on_unload(coordinator.async_add_listener(_async_add_devices))
+    _async_add_devices()
 
 
 APPLIANCE_ICONS = {
@@ -641,6 +694,17 @@ class MieleSensor(MieleEntity, SensorEntity):
 
     entity_description: MieleSensorDescription
 
+    def __init__(
+        self,
+        coordinator: MieleDataUpdateCoordinator,
+        device_id: str,
+        description: MieleSensorDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator, device_id, description)
+        if description.unique_id_fn is not None:
+            self._attr_unique_id = description.unique_id_fn(device_id, description)
+
     @property
     def native_value(self) -> StateType:
         """Return the state of the sensor."""
@@ -652,16 +716,6 @@ class MielePlateSensor(MieleSensor):
 
     entity_description: MieleSensorDescription
 
-    def __init__(
-        self,
-        coordinator: MieleDataUpdateCoordinator,
-        device_id: str,
-        description: MieleSensorDescription,
-    ) -> None:
-        """Initialize the plate sensor."""
-        super().__init__(coordinator, device_id, description)
-        self._attr_unique_id = f"{device_id}-{description.key}-{description.zone}"
-
     @property
     def native_value(self) -> StateType:
         """Return the state of the plate sensor."""
@@ -672,7 +726,7 @@ def native_value(self) -> StateType:
                 cast(
                     int,
                     self.device.state_plate_step[
-                        self.entity_description.zone - 1
+                        cast(int, self.entity_description.zone) - 1
                     ].value_raw,
                 )
             ).name

tests/components/miele/fixtures/4_actions.json

@@ -82,5 +82,20 @@
     "colors": [],
     "modes": [],
     "runOnTime": []
+  },
+  "DummyAppliance_12": {
+    "processAction": [],
+    "light": [2],
+    "ambientLight": [],
+    "startTime": [],
+    "ventilationStep": [],
+    "programId": [],
+    "targetTemperature": [],
+    "deviceName": true,
+    "powerOn": false,
+    "powerOff": true,
+    "colors": [],
+    "modes": [],
+    "runOnTime": []
   }
 }