Implement water_heater platform - part 2

custom_components/plugwise/const.py

@@ -77,15 +77,12 @@
 VENDOR: Final = "vendor"
 
 # Number constants
-MAX_BOILER_TEMP: Final = "maximum_boiler_temperature"
-MAX_DHW_TEMP: Final = "max_dhw_temperature"
 LOWER_BOUND: Final = "lower_bound"
 RESOLUTION: Final = "resolution"
 TEMPERATURE_OFFSET: Final = "temperature_offset"
 UPPER_BOUND: Final = "upper_bound"
 
 # Sensor constants
-DHW_TEMP: Final = "dhw_temperature"
 DHW_SETPOINT: Final = "domestic_hot_water_setpoint"
 EL_CONSUMED: Final = "electricity_consumed"
 EL_CONS_INTERVAL: Final = "electricity_consumed_interval"
@@ -150,6 +147,10 @@
 COOLING_ENA_SWITCH: Final ="cooling_ena_switch"
 SWITCHES: Final = "switches"
 
+# Water_heater constants
+BOILER_TEMP: Final = "boiler_temperature"
+DHW_TEMP: Final = "dhw_temperature"
+
 # Default directives
 DEFAULT_PORT: Final[int] = 80
 DEFAULT_TIMEOUT: Final[int] = 30
@@ -188,11 +189,8 @@
 }
 
 type NumberType = Literal[
-    "maximum_boiler_temperature",
-    "max_dhw_temperature",
     "temperature_offset",
 ]
-
 type SelectType = Literal[
     "select_dhw_mode",
     "select_gateway_mode",
@@ -207,3 +205,11 @@
     "regulation_modes",
     "zone_profiles",
 ]
+type WaterHeaterType = Literal[
+    "boiler_temperature",
+    "dhw_temperature",
+]
+type WaterHeaterOptionsType = Literal[
+    "boiler_modes",
+    "dhw_modes",
+]

custom_components/plugwise/manifest.json

@@ -7,7 +7,9 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
-  "requirements": ["plugwise==1.12.0"],
+  "requirements": [
+    "plugwise@git+https://github.com/plugwise/python-plugwise.git@water_heater_2"
+  ],
   "version": "0.65.0",
   "zeroconf": ["_plugwise._tcp.local."]
 }

custom_components/plugwise/number.py

@@ -15,7 +15,6 @@
 from .const import (
     LOGGER,
     LOWER_BOUND,
-    MAX_BOILER_TEMP,
     RESOLUTION,
     TEMPERATURE_OFFSET,
     UPPER_BOUND,
@@ -39,13 +38,6 @@ class PlugwiseNumberEntityDescription(NumberEntityDescription):
 
 # Upstream + is there a reason we didn't rename this one prefixed?
 NUMBER_TYPES = (
-    PlugwiseNumberEntityDescription(
-        key=MAX_BOILER_TEMP,
-        translation_key=MAX_BOILER_TEMP,
-        device_class=NumberDeviceClass.TEMPERATURE,
-        entity_category=EntityCategory.CONFIG,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    ),
     PlugwiseNumberEntityDescription(
         key=TEMPERATURE_OFFSET,
         translation_key=TEMPERATURE_OFFSET,
@@ -120,8 +112,6 @@ def __init__(
         self._attr_native_min_value = ctrl.get(LOWER_BOUND, 0.0)  # Upstream const
 
         native_step = ctrl.get(RESOLUTION, 0.5)  # Upstream const
-        if description.key != TEMPERATURE_OFFSET:  # Upstream const
-            native_step = max(native_step, 0.5)
         self._attr_native_step = native_step
 
     @property

custom_components/plugwise/translations/en.json

@@ -93,12 +93,6 @@
       }
     },
     "number": {
-      "max_dhw_temperature": {
-        "name": "Domestic hot water setpoint"
-      },
-      "maximum_boiler_temperature": {
-        "name": "Maximum boiler temperature setpoint"
-      },
       "temperature_offset": {
         "name": "Temperature offset"
       }
@@ -108,7 +102,7 @@
         "name": "DHW mode",
         "state": {
           "comfort": "Comfort",
-          "off": "Off"
+          "eco": "Eco"
         }
       },
       "select_gateway_mode": {
@@ -299,13 +293,21 @@
       }
     },
     "water_heater": {
-      "plugwise": {
-        "state": {
-          "auto": "Auto",
-          "boost": "Boost",
-          "comfort": "Comfort",
-          "eco": "Eco",
-          "off": "Off"
+      "boiler_temperature": {
+        "name": "Boiler temperature"
+      },
+      "dhw_temperature": {
+        "name": "DHW temperature",
+        "state_attributes": {
+          "dhw_modes": {
+            "state": {
+              "auto": "Auto",
+              "boost": "Boost",
+              "comfort": "Comfort",
+              "eco": "Eco",
+              "off": "Off"
+            }
+          }
         }
       }
     }

custom_components/plugwise/translations/nl.json

@@ -93,12 +93,6 @@
       }
     },
     "number": {
-      "max_dhw_temperature": {
-        "name": "Instelpunt sanitair warm water"
-      },
-      "maximum_boiler_temperature": {
-        "name": "Instelpunt maximale boiler temperatuur"
-      },
       "temperature_offset": {
         "name": "Temperatuurcompensatie"
       }
@@ -108,7 +102,7 @@
         "name": "SWW modus",
         "state": {
           "comfort": "Comfort",
-          "off": "Uit"
+          "eco": "Eco"
         }
       },
       "select_gateway_mode": {
@@ -299,14 +293,11 @@
       }
     },
     "water_heater": {
-      "plugwise": {
-        "state": {
-          "auto": "Auto",
-          "boost": "Boost",
-          "comfort": "Comfort",
-          "eco": "Eco",
-          "off": "Off"
-        }
+      "boiler_temperature": {
+        "name": "Boiler temperatuur"
+      },
+      "dhw_temperature": {
+        "name": "SWW temperatuur"
       }
     }
   },

custom_components/plugwise/water_heater.py

@@ -1,38 +1,61 @@
 """Plugwise water heater component for HomeAssistant."""
 
-from typing import Any
+from dataclasses import dataclass
+from typing import Any, cast
 
 from homeassistant.components.water_heater import (
     WaterHeaterEntity,
+    WaterHeaterEntityDescription,
     WaterHeaterEntityFeature,
 )
 from homeassistant.const import (
-    ATTR_NAME,
     ATTR_TEMPERATURE,
-    STATE_OFF,
+    STATE_ON,
+    EntityCategory,
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
+    BOILER_TEMP,
     DHW_MODE,
     DHW_MODES,
-    DHW_SETPOINT,
     DHW_TEMP,
     LOGGER,
     LOWER_BOUND,
-    MAX_DHW_TEMP,
-    SENSORS,
-    TARGET_TEMP,
     UPPER_BOUND,
-    WATER_TEMP,
+    WaterHeaterOptionsType,
+    WaterHeaterType,
 )
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
 
 
+@dataclass(frozen=True, kw_only=True)
+class PlugwiseWaterHeaterEntityDescription(WaterHeaterEntityDescription):
+    """Class describing Plugwise WaterHeater entities."""
+
+    key: WaterHeaterType
+    options_key: WaterHeaterOptionsType | None
+
+# Upstream + is there a reason we didn't rename this one prefixed?
+WATERHEATER_TYPES = (
+    PlugwiseWaterHeaterEntityDescription(
+        key=BOILER_TEMP,
+        translation_key=BOILER_TEMP,
+        entity_category=EntityCategory.CONFIG,
+        options_key=None,
+    ),
+    PlugwiseWaterHeaterEntityDescription(
+        key=DHW_TEMP,
+        translation_key=DHW_TEMP,
+        entity_category=EntityCategory.CONFIG,
+        options_key=DHW_MODES,
+    ),
+)
+
 async def async_setup_entry(
     _hass: HomeAssistant,
     entry: PlugwiseConfigEntry,
@@ -50,9 +73,15 @@ def _add_entities() -> None:
         entities: list[PlugwiseWaterHeaterEntity] = []
         for device_id in coordinator.new_devices:
             device = coordinator.data[device_id]
-            if device.get(MAX_DHW_TEMP) is not None:
-                entities.append(PlugwiseWaterHeaterEntity(coordinator, device_id))
-                LOGGER.debug("Add %s water_heater", device[ATTR_NAME])
+            for description in WATERHEATER_TYPES:
+                if description.key in device:
+                    entities.append(
+                        PlugwiseWaterHeaterEntity(coordinator, device_id, description)
+                    )
+                    LOGGER.debug(
+                        "Add %s %s water_heater", device["name"], description.translation_key
+                    )
+
         async_add_entities(entities)
 
     _add_entities()
@@ -62,61 +91,71 @@ def _add_entities() -> None:
 class PlugwiseWaterHeaterEntity(PlugwiseEntity, WaterHeaterEntity):
     """Representation of a Plugwise water heater."""
 
-    _attr_name = None
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    entity_description: PlugwiseWaterHeaterEntityDescription
 
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
+        description: PlugwiseWaterHeaterEntityDescription,
     ) -> None:
         """Initialise the water_heater."""
         super().__init__(coordinator, device_id)
-        self._attr_unique_id = f"{device_id}-water_heater"
-
-        max_dhw_temp_bounds = self.device.get(MAX_DHW_TEMP, {})
-        if max_dhw_temp_bounds:
-            self._attr_max_temp = max_dhw_temp_bounds.get(UPPER_BOUND, 75.0)
-            self._attr_min_temp = max_dhw_temp_bounds.get(LOWER_BOUND, 40.0)
-        self._attr_supported_features = WaterHeaterEntityFeature.OPERATION_MODE
-        self._attr_supported_features |= WaterHeaterEntityFeature.TARGET_TEMPERATURE
-
+        self.entity_description = description
+        temp_data = self.device.get(description.key, {})
+        if temp_data:
+            self._attr_max_temp = temp_data.get(UPPER_BOUND, 75.0)
+            self._attr_min_temp = temp_data.get(LOWER_BOUND, 40.0)
+        self._attr_supported_features = WaterHeaterEntityFeature.TARGET_TEMPERATURE
+        if description.options_key is not None:
+            self._attr_supported_features |= WaterHeaterEntityFeature.OPERATION_MODE
+        self._attr_temperature_unit = UnitOfTemperature.CELSIUS
+        self._attr_unique_id = f"{device_id}-{description.key}"
 
     @property
     def current_operation(self) -> str | None:
         """Return current readable operation mode."""
+        if self.entity_description.options_key is None:
+            return STATE_ON
         return self.device.get(DHW_MODE)
 
     @property
     def current_temperature(self) -> float | None:
         """Return the current water temperature."""
-        boiler_temperature = self.device.get(SENSORS, {}).get(WATER_TEMP)
-        dhw_temperature = self.device.get(SENSORS, {}).get(DHW_TEMP)
-        return dhw_temperature or boiler_temperature
+        return self.device.get(self.entity_description.key, {}).get("current")
 
     @property
     def operation_list(self) -> list[str]:
-        """Return the list of available operation modes."""
-        if (op_list := self.device.get(DHW_MODES, [])):
-            return op_list
-        return [STATE_OFF]  # pragma: no cover
+        """Return the list of available operation modes.
+
+        When no list is available the water_heater only has an "on" mode.
+        """
+        if self.entity_description.options_key is not None:
+            op_list = self.device.get(self.entity_description.options_key)
+            if op_list is not None:
+                return cast(list[str], op_list)
+
+        return [STATE_ON]
 
     @property
     def target_temperature(self) -> float | None:
         """Return the water temperature we try to reach."""
-        return (
-            self.device.get(MAX_DHW_TEMP, {}).get(TARGET_TEMP)
-            or self.device.get(SENSORS, {}).get(DHW_SETPOINT)
-        )
+        return self.device.get(self.entity_description.key, {}).get("setpoint")
 
     @plugwise_command
     async def async_set_operation_mode(self, operation_mode: str) -> None:
         """Set the operation mode."""
+        if self.entity_description.options_key is None:
+            return
         list_type: int = len(self.operation_list)
         await self.coordinator.api.set_dhw_mode(DHW_MODE, self._dev_id, list_type, operation_mode)
 
     @plugwise_command
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         if (temperature := kwargs.get(ATTR_TEMPERATURE)) is not None:
-            await self.coordinator.api.set_number(self._dev_id, MAX_DHW_TEMP, float(temperature))
+            await self.coordinator.api.set_number(
+                self._dev_id,
+                self.entity_description.key,
+                float(temperature),
+            )