Feat/water heater heat pump (#1367)

Author: BottlecapDave

_docs/entities/heat_pump.md

@@ -24,15 +24,30 @@ This represents the temperature reported by a sensor (e.g. Cosy Pod) that is ass
 
 `climate.octopus_energy_heat_pump_{{HEAT_PUMP_ID}}_{{ZONE_CODE}}`
 
-This can be used to control the target temperature and mode for a given zone (e.g. water or zone 1) linked to your heat pump. It will also display the current temperature linked to the primary sensor for the zone.
+This can be used to control the target temperature and mode for a given zone (e.g. zone 1) linked to your heat pump. It will also display the current temperature linked to the primary sensor for the zone.
 
 The following operation modes are available
 
 * `Heat` - This represents as `on` in the app
 * `Off` - This represents as `off` in the app
 * `Auto` - This represents as `auto` in the app
 
-In addition, there is the preset of `boost`, which activates boost mode for the zone for 1 hour. If you require boost to be on for a different amount of time, then you can use the [available service](../services.md#octopus_energyboost_heat_pump_zone).
+In addition, there is the preset of `boost`. When `boost` is selected, this activates boost mode for the zone for 1 hour. If a target temperature is not set, then this will default to 50 degrees c. If you require boost to be on for a different amount of time or with a different target temperature, then you can use the [available service](../services.md#octopus_energyboost_heat_pump_zone).
+
+## Water Heater
+
+`water_heater.octopus_energy_heat_pump_{{HEAT_PUMP_ID}}`
+
+This can be used to control the target temperature and mode for a given water heater linked to your heat pump. It will also display the current temperature linked to the primary sensor for the zone.
+
+The following operation modes are available
+
+* `on` - This represents as `on` in the app
+* `off` - This represents as `off` in the app
+* `heat_pump` - This represents as `auto` in the app
+* `high_demand` - This represents as `boost` in the app
+
+When `boost` is selected, this activates boost mode for the zone for 1 hour. If a target temperature is not set, then this will default to 50 degrees c. If you require boost to be on for a different amount of time or with a different target temperature, then you can use the [available service](../services.md#octopus_energyboost_heat_pump_zone).
 
 !!! note
 

custom_components/octopus_energy/__init__.py

@@ -85,7 +85,7 @@
   REPAIR_UNKNOWN_INTELLIGENT_PROVIDER
 )
 
-ACCOUNT_PLATFORMS = ["sensor", "binary_sensor", "number", "switch", "text", "time", "event", "select", "climate"]
+ACCOUNT_PLATFORMS = ["sensor", "binary_sensor", "number", "switch", "text", "time", "event", "select", "climate", "water_heater"]
 TARGET_RATE_PLATFORMS = ["binary_sensor"]
 COST_TRACKER_PLATFORMS = ["sensor"]
 TARIFF_COMPARISON_PLATFORMS = ["sensor"]

custom_components/octopus_energy/climate.py

@@ -102,7 +102,7 @@ def setup_heat_pump_sensors(hass: HomeAssistant, client: OctopusEnergyApiClient,
   if heat_pump_response is not None and heat_pump_response.octoHeatPumpControllerConfiguration is not None:
     for zone in heat_pump_response.octoHeatPumpControllerConfiguration.zones:
       if zone.configuration is not None:
-        if zone.configuration.enabled == False:
+        if zone.configuration.enabled == False or zone.configuration.zoneType == "WATER":
           continue
 
         entities.append(OctopusEnergyHeatPumpZone(

custom_components/octopus_energy/heat_pump/water_heater.py

@@ -0,0 +1,233 @@
+from datetime import datetime, timedelta
+import logging
+from typing import List
+
+from homeassistant.util.dt import (utcnow)
+from homeassistant.exceptions import ServiceValidationError
+
+from homeassistant.const import (
+    UnitOfTemperature,
+    PRECISION_HALVES,
+    ATTR_TEMPERATURE,
+    STATE_OFF,
+    STATE_ON
+)
+from homeassistant.core import HomeAssistant, callback
+
+from homeassistant.util.dt import (now)
+from homeassistant.helpers.update_coordinator import (
+  CoordinatorEntity
+)
+from homeassistant.components.water_heater import (
+    WaterHeaterEntity,
+    WaterHeaterEntityFeature,
+    STATE_HEAT_PUMP,
+    STATE_HIGH_DEMAND
+)
+
+from .base import (BaseOctopusEnergyHeatPumpSensor)
+from ..utils.attributes import dict_to_typed_dict
+from ..api_client.heat_pump import ConfigurationZone, HeatPump, Sensor, Zone
+from ..coordinators.heat_pump_configuration_and_status import HeatPumpCoordinatorResult
+from ..api_client import OctopusEnergyApiClient
+from ..const import DEFAULT_BOOST_TEMPERATURE_WATER, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+OE_TO_HA_STATE = {
+    "AUTO": STATE_HEAT_PUMP,
+    "BOOST": STATE_HIGH_DEMAND,
+    "ON": STATE_ON,
+    "OFF": STATE_OFF,
+}
+
+HA_TO_OE_STATE = {
+    STATE_HEAT_PUMP: "AUTO",
+    STATE_HIGH_DEMAND: "BOOST",
+    STATE_ON: "ON",
+    STATE_OFF: "OFF",
+}
+
+class OctopusEnergyHeatPumpWaterHeater(CoordinatorEntity, BaseOctopusEnergyHeatPumpSensor, WaterHeaterEntity):
+  """Sensor for interacting with a heat pump water heater zone."""
+
+  _attr_supported_features = (
+    WaterHeaterEntityFeature.ON_OFF
+    | WaterHeaterEntityFeature.TARGET_TEMPERATURE
+    | WaterHeaterEntityFeature.OPERATION_MODE
+  )
+
+  _attr_operation_list = [STATE_ON, STATE_OFF, STATE_HEAT_PUMP, STATE_HIGH_DEMAND]
+  _attr_current_operation = None
+  _attr_temperature_unit = UnitOfTemperature.CELSIUS
+  _attr_precision = PRECISION_HALVES
+
+  def __init__(self, hass: HomeAssistant, coordinator, client: OctopusEnergyApiClient, account_id: str, heat_pump_id: str, heat_pump: HeatPump, zone: ConfigurationZone, is_mocked: bool):
+    """Init sensor."""
+    self._zone = zone
+    self._account_id = account_id
+    self._client = client
+    self._is_mocked = is_mocked
+    self._end_timestamp = None
+
+    self._attr_min_temp = 40
+    self._attr_max_temp = 60
+
+    # Pass coordinator to base class
+    CoordinatorEntity.__init__(self, coordinator)
+    BaseOctopusEnergyHeatPumpSensor.__init__(self, hass, heat_pump_id, heat_pump, "water_heater")
+
+    self._state = None
+    self._last_updated = None
+
+  @property
+  def unique_id(self):
+    """The id of the sensor."""
+    return f"octopus_energy_heat_pump_{self._heat_pump_id}"
+    
+  @property
+  def name(self):
+    """Name of the sensor."""
+    return f"Zone ({self._zone.configuration.displayName}) Heat Pump ({self._heat_pump_id})"
+  
+  @callback
+  def _handle_coordinator_update(self) -> None:
+    """Retrieve the previous rate."""
+
+    current = now()
+    result: HeatPumpCoordinatorResult = self.coordinator.data if self.coordinator is not None and self.coordinator.data is not None else None    
+    if (result is not None and 
+        result.data is not None and 
+        result.data.octoHeatPumpControllerStatus is not None and
+        result.data.octoHeatPumpControllerStatus.zones and
+        (self._last_updated is None or self._last_updated < result.last_retrieved)):
+      _LOGGER.debug(f"Updating OctopusEnergyHeatPumpWaterHeater for '{self._heat_pump_id}/{self._zone.configuration.code}'")
+
+      zones: List[Zone] = result.data.octoHeatPumpControllerStatus.zones
+      for zone in zones:
+        if zone.telemetry is not None and zone.zone == self._zone.configuration.code and zone.telemetry.mode is not None:
+
+          if zone.telemetry.mode in OE_TO_HA_STATE:
+            self._attr_current_operation = OE_TO_HA_STATE[zone.telemetry.mode]
+          else:
+            raise Exception(f"Unexpected heat pump mode detected: {zone.telemetry.mode}")
+
+          self._attr_target_temperature = None
+          if zone.telemetry.setpointInCelsius is not None and zone.telemetry.setpointInCelsius > 0:
+            self._attr_target_temperature = zone.telemetry.setpointInCelsius
+
+          if result.data.octoHeatPumpControllerStatus.sensors and self._zone.configuration.primarySensor:
+            sensors: List[Sensor] = result.data.octoHeatPumpControllerStatus.sensors
+            for sensor in sensors:
+              if sensor.code == self._zone.configuration.primarySensor and sensor.telemetry is not None:
+                self._attr_current_temperature = sensor.telemetry.temperatureInCelsius
+                self._attr_current_humidity = sensor.telemetry.humidityPercentage
+
+          if result.data.octoHeatPumpControllerConfiguration is not None and result.data.octoHeatPumpControllerConfiguration.zones:
+            configs: List[ConfigurationZone] = result.data.octoHeatPumpControllerConfiguration.zones
+            for config in configs:
+              if config.configuration is not None and config.configuration.code == self._zone.configuration.code and config.configuration.currentOperation is not None:
+                self._end_timestamp = datetime.fromisoformat(config.configuration.currentOperation.end) if config.configuration.currentOperation.end is not None else None
+      
+      self._last_updated = current
+
+    self._attributes = dict_to_typed_dict(self._attributes)
+    super()._handle_coordinator_update()
+
+  async def async_set_operation_mode(self, operation_mode: str):
+    """Set new target operation mode."""
+    try:
+      self._attr_current_operation = operation_mode
+      
+      if OE_TO_HA_STATE["BOOST"] == self._attr_current_operation:
+        self._end_timestamp = utcnow()
+        self._end_timestamp += timedelta(hours=1)
+        await self._client.async_boost_heat_pump_zone(
+          self._account_id,
+          self._heat_pump_id,
+          self._zone.configuration.code,
+          self._end_timestamp,
+          self._attr_target_temperature if self._attr_target_temperature is not None else DEFAULT_BOOST_TEMPERATURE_WATER
+        )
+      else:
+        zone_mode = self.get_zone_mode()
+        await self._client.async_set_heat_pump_zone_mode(self._account_id, self._heat_pump_id, self._zone.configuration.code, zone_mode, self._attr_target_temperature)
+    except Exception as e:
+      if self._is_mocked:
+        _LOGGER.warning(f'Suppress async_set_preset_mode error due to mocking mode: {e}')
+      else:
+        raise
+
+    self.async_write_ha_state()
+
+  async def async_turn_on(self):
+    """Turn the entity on."""
+    try:
+      self._attr_current_operation = OE_TO_HA_STATE["ON"]
+      await self._client.async_set_heat_pump_zone_mode(self._account_id, self._heat_pump_id, self._zone.configuration.code, 'ON', self._attr_target_temperature)
+    except Exception as e:
+      if self._is_mocked:
+        _LOGGER.warning(f'Suppress async_turn_on error due to mocking mode: {e}')
+      else:
+        raise
+
+    self.async_write_ha_state()
+
+  async def async_turn_off(self):
+    """Turn the entity off."""
+    try:
+      self._attr_current_operation = OE_TO_HA_STATE["OFF"]
+      await self._client.async_set_heat_pump_zone_mode(self._account_id, self._heat_pump_id, self._zone.configuration.code, 'OFF', None)
+    except Exception as e:
+      if self._is_mocked:
+        _LOGGER.warning(f'Suppress async_turn_off error due to mocking mode: {e}')
+      else:
+        raise
+
+    self.async_write_ha_state()
+
+  async def async_set_temperature(self, **kwargs) -> None:
+    """Set new target temperature."""
+
+    try:
+      self._attr_target_temperature = kwargs[ATTR_TEMPERATURE]
+      if OE_TO_HA_STATE["BOOST"] == self._attr_current_operation:
+        await self._client.async_boost_heat_pump_zone(self._account_id, self._heat_pump_id, self._zone.configuration.code, self._end_timestamp, self._attr_target_temperature)
+      else:
+        zone_mode = self.get_zone_mode()
+        await self._client.async_set_heat_pump_zone_mode(self._account_id, self._heat_pump_id, self._zone.configuration.code, zone_mode, self._attr_target_temperature)
+    except Exception as e:
+      if self._is_mocked:
+        _LOGGER.warning(f'Suppress async_set_temperature error due to mocking mode: {e}')
+      else:
+        raise
+
+    self.async_write_ha_state()
+
+  @callback
+  async def async_boost_heat_pump_zone(self, hours: int, minutes: int, target_temperature: float | None = None):
+    """Boost the heat pump zone"""
+
+    if target_temperature is not None:
+      if target_temperature < self._attr_min_temp or target_temperature > self._attr_max_temp:
+        raise ServiceValidationError(
+          translation_domain=DOMAIN,
+          translation_key="invalid_target_temperature",
+          translation_placeholders={ 
+            "min_temperature": self._attr_min_temp,
+            "max_temperature": self._attr_max_temp
+          },
+        )
+
+    self._end_timestamp = utcnow()
+    self._end_timestamp += timedelta(hours=hours, minutes=minutes)
+    self._attr_current_operation = OE_TO_HA_STATE["BOOST"]
+    await self._client.async_boost_heat_pump_zone(self._account_id, self._heat_pump_id, self._zone.configuration.code, self._end_timestamp, target_temperature if target_temperature is not None else self._attr_target_temperature)
+
+    self.async_write_ha_state()
+
+  def get_zone_mode(self):
+    if self._attr_current_operation in HA_TO_OE_STATE:
+      return HA_TO_OE_STATE[self._attr_current_operation]
+    else:
+      raise Exception(f"Unexpected heat pump mode detected: {self._attr_current_operation}")

custom_components/octopus_energy/heat_pump/zone.py

@@ -8,7 +8,6 @@
 from homeassistant.const import (
     UnitOfTemperature,
     PRECISION_HALVES,
-    PRECISION_TENTHS,
     ATTR_TEMPERATURE
 )
 from homeassistant.core import HomeAssistant, callback
@@ -52,7 +51,6 @@ class OctopusEnergyHeatPumpZone(CoordinatorEntity, BaseOctopusEnergyHeatPumpSens
   _attr_preset_modes = [PRESET_NONE, PRESET_BOOST]
   _attr_preset_mode = None
   _attr_temperature_unit = UnitOfTemperature.CELSIUS
-  _attr_target_temperature_step = PRECISION_TENTHS
   _attr_target_temperature_step = PRECISION_HALVES
 
   def __init__(self, hass: HomeAssistant, coordinator, client: OctopusEnergyApiClient, account_id: str, heat_pump_id: str, heat_pump: HeatPump, zone: ConfigurationZone, is_mocked: bool):

custom_components/octopus_energy/water_heater.py

@@ -0,0 +1,88 @@
+import logging
+
+from custom_components.octopus_energy.heat_pump.water_heater import OctopusEnergyHeatPumpWaterHeater
+import voluptuous as vol
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_platform
+import homeassistant.helpers.config_validation as cv
+
+from .api_client.heat_pump import HeatPumpResponse
+from .heat_pump import get_mock_heat_pump_id
+from .heat_pump.zone import OctopusEnergyHeatPumpZone
+from .utils.debug_overrides import async_get_account_debug_override
+
+from .const import (
+  CONFIG_ACCOUNT_ID,
+  DATA_ACCOUNT,
+  DATA_CLIENT,
+  DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_COORDINATOR,
+  DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_KEY,
+  DOMAIN,
+
+  CONFIG_MAIN_API_KEY
+)
+from .api_client import OctopusEnergyApiClient
+
+_LOGGER = logging.getLogger(__name__)
+
+async def async_setup_entry(hass, entry, async_add_entities):
+  """Setup sensors based on our entry"""
+
+  config = dict(entry.data)
+
+  if entry.options:
+    config.update(entry.options)
+
+  if CONFIG_MAIN_API_KEY in config:
+    await async_setup_default_sensors(hass, config, async_add_entities)
+
+  return True
+
+async def async_setup_default_sensors(hass, config, async_add_entities):
+  _LOGGER.debug('Setting up default sensors')
+
+  entities = []
+
+  account_id = config[CONFIG_ACCOUNT_ID]
+  client = hass.data[DOMAIN][account_id][DATA_CLIENT]
+  account_debug_override = await async_get_account_debug_override(hass, account_id)
+  account_result = hass.data[DOMAIN][account_id][DATA_ACCOUNT]
+  account_info = account_result.account if account_result is not None else None
+
+  mock_heat_pump = account_debug_override.mock_heat_pump if account_debug_override is not None else False
+  if mock_heat_pump:
+    heat_pump_id = get_mock_heat_pump_id()
+    key = DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_KEY.format(heat_pump_id)
+    coordinator = hass.data[DOMAIN][account_id][DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_COORDINATOR.format(heat_pump_id)]
+    entities.extend(setup_heat_pump_sensors(hass, client, account_id, heat_pump_id, hass.data[DOMAIN][account_id][key].data, coordinator, mock_heat_pump))
+  elif "heat_pump_ids" in account_info:
+    for heat_pump_id in account_info["heat_pump_ids"]:
+      key = DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_KEY.format(heat_pump_id)
+      coordinator = hass.data[DOMAIN][account_id][DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_COORDINATOR.format(heat_pump_id)]
+      entities.extend(setup_heat_pump_sensors(hass, client, account_id, heat_pump_id, hass.data[DOMAIN][account_id][key].data, coordinator, mock_heat_pump))
+
+  async_add_entities(entities)
+
+def setup_heat_pump_sensors(hass: HomeAssistant, client: OctopusEnergyApiClient, account_id: str, heat_pump_id: str, heat_pump_response: HeatPumpResponse, coordinator, mock_heat_pump: bool):
+
+  entities = []
+
+  if heat_pump_response is not None and heat_pump_response.octoHeatPumpControllerConfiguration is not None:
+    for zone in heat_pump_response.octoHeatPumpControllerConfiguration.zones:
+      if zone.configuration is not None:
+        if zone.configuration.enabled == False or zone.configuration.zoneType != "WATER":
+          continue
+
+        entities.append(OctopusEnergyHeatPumpWaterHeater(
+          hass,
+          coordinator,
+          client,
+          account_id,
+          heat_pump_id,
+          heat_pump_response.octoHeatPumpControllerConfiguration.heatPump,
+          zone,
+          mock_heat_pump
+        ))
+
+  return entities