chore: Reverted exposing to standard sensor

Author: BottlecapDave

_docs/services.md

@@ -258,6 +258,9 @@ Allows you to set the heat pump configuration for fixed and weather compensated
 !!! warning
     Changing this configuration without a good understanding of heat loss and emitter output can cause cycling, defrosting, or incorrect heat delivery. 
 
+!!! note
+    Corresponding sensors will not update straight away upon calling.
+
 | Attribute                | Optional | Description                                                                                                           |
 | ------------------------ | -------- | --------------------------------------------------------------------------------------------------------------------- |
 | `target.entity_id`       | `no`     | Any climate entity belonging to the heat pump which the configuration should be applied to (e.g. `climate.octopus_energy_heat_pump_{{HEAT_PUMP_ID}}_{{ZONE_CODE}}`). |

custom_components/octopus_energy/api_client/__init__.py

@@ -409,22 +409,6 @@
 }}
 '''
 
-heat_pump_update_fixed_target_flow_temp_mutation = '''
-mutation {{
-  octoHeatPumpUpdateFlowTemperatureConfiguration(
-    euid: "{euid}"
-    flowTemperatureInput: {{
-      flowTemperature: {{
-        value: "{fixed_flow_temperature}", 
-        unit: DEGREES_CELSIUS
-      }}
-    }}
-  ) {{
-    transactionId
-  }}
-}}
-'''
-
 heat_pump_status_and_config_query = '''
 query {{
   octoHeatPumpControllerStatus(accountNumber: "{account_id}", euid: "{euid}") {{
@@ -942,23 +926,6 @@ async def async_set_heat_pump_flow_temp_config(self, euid: str, weather_comp_ena
     except TimeoutError:
       _LOGGER.warning(f'Failed to connect. Timeout of {self._timeout} exceeded.')
       raise TimeoutException()
-    
-  async def async_set_heat_pump_fixed_target_flow_temp(self, euid: str, fixed_flow_temperature: float):
-    """Sets the flow temperature for a given heat pump zone"""
-    await self.async_refresh_token()
-
-    try:
-      client = self._create_client_session()
-      url = f'{self._base_url}/v1/graphql/'
-      query = heat_pump_update_fixed_target_flow_temp_mutation.format(euid=euid, fixed_flow_temperature=fixed_flow_temperature) 
-      payload = { "query": query }
-      headers = { "Authorization": f"JWT {self._graphql_token}" }
-      async with client.post(url, json=payload, headers=headers) as heat_pump_response:
-        await self.__async_read_response__(heat_pump_response, url)
-    
-    except TimeoutError:
-      _LOGGER.warning(f'Failed to connect. Timeout of {self._timeout} exceeded.')
-      raise TimeoutException()
 
   async def async_set_heat_pump_zone_mode(self, account_id: str, euid: str, zone_id: str, zone_mode: str, target_temperature: float | None):
     """Sets the mode for a given heat pump zone"""

custom_components/octopus_energy/heat_pump/sensor_fixed_target_flow_temperature.py

@@ -1,4 +1,6 @@
+from datetime import datetime
 import logging
+from typing import List
 
 from homeassistant.const import (
     STATE_UNAVAILABLE,
@@ -7,37 +9,34 @@
 )
 from homeassistant.core import HomeAssistant, callback
 
+from homeassistant.util.dt import (now)
 from homeassistant.helpers.update_coordinator import (
   CoordinatorEntity
 )
-from homeassistant.components.number import RestoreNumber, NumberDeviceClass, NumberMode
-from homeassistant.util.dt import (now)
+from homeassistant.components.sensor import (
+  RestoreSensor,
+  SensorDeviceClass,
+  SensorStateClass,
+)
 
 from .base import (BaseOctopusEnergyHeatPumpSensor)
 from ..utils.attributes import dict_to_typed_dict
 from ..api_client.heat_pump import HeatPump
 from ..coordinators.heat_pump_configuration_and_status import HeatPumpCoordinatorResult
-from ..api_client import OctopusEnergyApiClient
 
 _LOGGER = logging.getLogger(__name__)
 
-class OctopusEnergyHeatPumpFixedTargetFlowTemperature(CoordinatorEntity, RestoreNumber, BaseOctopusEnergyHeatPumpSensor):
-  """Sensor for reading and setting the fixed target flow temperature of a heat pump."""
+class OctopusEnergyHeatPumpSensorFixedTargetFlowTemperature(CoordinatorEntity, BaseOctopusEnergyHeatPumpSensor, RestoreSensor):
+  """Sensor for displaying the live heat output of a heat pump."""
 
-  def __init__(self, hass: HomeAssistant, client: OctopusEnergyApiClient, coordinator, heat_pump_id: str, heat_pump: HeatPump):
+  def __init__(self, hass: HomeAssistant, coordinator, heat_pump_id: str, heat_pump: HeatPump):
     """Init sensor."""
     # Pass coordinator to base class
     CoordinatorEntity.__init__(self, coordinator)
-    BaseOctopusEnergyHeatPumpSensor.__init__(self, hass, heat_pump_id, heat_pump, entity_domain="number")
+    BaseOctopusEnergyHeatPumpSensor.__init__(self, hass, heat_pump_id, heat_pump)
 
-  
     self._state = None
-    self._client = client
     self._last_updated = None
-    self._attr_native_min_value = 30
-    self._attr_native_max_value = 70
-    self._attr_native_step = 1
-    self._attr_mode = NumberMode.BOX
 
   @property
   def unique_id(self):
@@ -49,45 +48,35 @@ def name(self):
     """Name of the sensor."""
     return f"Fixed Target Flow Temperature Heat Pump ({self._heat_pump_id})"
 
+  @property
+  def state_class(self):
+    """The state class of sensor"""
+    return SensorStateClass.MEASUREMENT
+
   @property
   def device_class(self):
     """The type of sensor"""
-    return NumberDeviceClass.TEMPERATURE
-  
+    return SensorDeviceClass.TEMPERATURE
+
+  @property
+  def icon(self):
+    """Icon of the sensor."""
+    return "mdi:thermometer"
+
   @property
   def native_unit_of_measurement(self):
-    """The unit of measurement of sensor"""
+    """Unit of measurement of the sensor."""
     return UnitOfTemperature.CELSIUS
 
   @property
   def extra_state_attributes(self):
     """Attributes of the sensor."""
     return self._attributes
-
+  
   @property
-  def native_value(self) -> float:
+  def native_value(self):
     return self._state
 
-  async def async_set_native_value(self, value: float) -> None:
-    """Set new value."""
-    if value and value % self._attr_native_step == 0:
-      try:
-        await self._client.async_set_heat_pump_fixed_target_flow_temp(
-          self._heat_pump_id,
-          value
-        )
-      except Exception as e:
-        if self._is_mocked:
-          _LOGGER.warning(f'Suppress async_set_native_value error due to mocking mode: {e}')
-        else:
-          raise
-
-      self._state = value
-      self._last_updated = now()
-      self.async_write_ha_state()
-    else:
-      raise Exception(f"Value must be between {self._attr_native_min_value} and {self._attr_native_max_value} and be a multiple of {self._attr_native_step}")
-  
   @callback
   def _handle_coordinator_update(self) -> None:
     """Retrieve the configured fixed target flow temperature for the heat pump."""
@@ -100,7 +89,7 @@ def _handle_coordinator_update(self) -> None:
         and result.data.octoHeatPumpControllerConfiguration.heatPump is not None
         and result.data.octoHeatPumpControllerConfiguration.heatPump.heatingFlowTemperature is not None
         and result.data.octoHeatPumpControllerConfiguration.heatPump.heatingFlowTemperature.currentTemperature is not None):
-      _LOGGER.debug(f"Updating OctopusEnergyHeatPumpNumberFixedTargetFlowTemperature for '{self._heat_pump_id}'")
+      _LOGGER.debug(f"Updating OctopusEnergyHeatPumpSensorFixedTargetFlowTemperature for '{self._heat_pump_id}'")
 
       self._state = float(result.data.octoHeatPumpControllerConfiguration.heatPump.heatingFlowTemperature.currentTemperature.value)
       self._last_updated = current
@@ -119,4 +108,4 @@ async def async_added_to_hass(self):
       self._state = None if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN) else last_sensor_state.native_value
       self._attributes = dict_to_typed_dict(state.attributes, [])
 
-      _LOGGER.debug(f'Restored OctopusEnergyHeatPumpNumberFixedTargetFlowTemperature state: {self._state}')
+      _LOGGER.debug(f'Restored OctopusEnergyHeatPumpSensorFixedTargetFlowTemperature state: {self._state}')

custom_components/octopus_energy/heat_pump/water_heater.py

@@ -154,7 +154,7 @@ async def async_set_operation_mode(self, operation_mode: str):
         await self._client.async_set_heat_pump_zone_mode(self._account_id, self._heat_pump_id, self._zone.configuration.code, zone_mode, None)
     except Exception as e:
       if self._is_mocked:
-        _LOGGER.warning(f'Suppress async_set_preset_mode error due to mocking mode: {e}')
+        _LOGGER.warning(f'Suppress async_set_operation_mode error due to mocking mode: {e}')
       else:
         raise
 

custom_components/octopus_energy/number.py

@@ -1,9 +1,5 @@
 import logging
 
-from .api_client import OctopusEnergyApiClient
-from .api_client.heat_pump import HeatPumpResponse
-from .heat_pump import get_mock_heat_pump_id
-from .heat_pump.sensor_fixed_target_flow_temperature import OctopusEnergyHeatPumpFixedTargetFlowTemperature
 
 from .utils.debug_overrides import async_get_account_debug_override
 
@@ -13,10 +9,7 @@
 
 from .const import (
   CONFIG_ACCOUNT_ID,
-  DATA_ACCOUNT,
   DATA_CLIENT,
-  DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_COORDINATOR,
-  DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_KEY,
   DATA_INTELLIGENT_DEVICE,
   DOMAIN,
 
@@ -38,29 +31,13 @@ async def async_setup_entry(hass, entry, async_add_entities):
   entities = []
 
   if CONFIG_MAIN_API_KEY in entry.data:
-    entities.extend(await async_setup_intelligent_sensors(hass, config, async_add_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(setup_heat_pump_sensors(hass, client, heat_pump_id, hass.data[DOMAIN][account_id][key].data, coordinator))
-    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(setup_heat_pump_sensors(hass, client, heat_pump_id, hass.data[DOMAIN][account_id][key].data, coordinator))
+    entities.extend(await async_setup_intelligent_sensors(hass, config))
+
+  async_add_entities(entities)
 
   return True
 
-async def async_setup_intelligent_sensors(hass, config, async_add_entities):
+async def async_setup_intelligent_sensors(hass, config):
   _LOGGER.debug('Setting up intelligent sensors')
 
   entities = []
@@ -78,19 +55,4 @@ async def async_setup_intelligent_sensors(hass, config, async_add_entities):
     if intelligent_features.charge_limit_supported == True:
       entities.append(OctopusEnergyIntelligentChargeTarget(hass, settings_coordinator, client, intelligent_device, account_id, account_debug_override.mock_intelligent_controls if account_debug_override is not None else False))
 
-  async_add_entities(entities)
-
-def setup_heat_pump_sensors(hass, client: OctopusEnergyApiClient, heat_pump_id: str, heat_pump_response: HeatPumpResponse, coordinator):
-
-  entities = []
-
-  if heat_pump_response is not None and heat_pump_response.octoHeatPumpControllerConfiguration is not None:
-    entities.append(OctopusEnergyHeatPumpFixedTargetFlowTemperature(
-      hass,
-      client,
-      coordinator,
-      heat_pump_id,
-      heat_pump_response.octoHeatPumpControllerConfiguration.heatPump
-    ))
-
   return entities

custom_components/octopus_energy/sensor.py

@@ -68,6 +68,7 @@
 from .heat_pump.sensor_lifetime_scop import OctopusEnergyHeatPumpSensorLifetimeSCoP
 from .heat_pump.sensor_lifetime_heat_output import OctopusEnergyHeatPumpSensorLifetimeHeatOutput
 from .heat_pump.sensor_lifetime_energy_input import OctopusEnergyHeatPumpSensorLifetimeEnergyInput
+from .heat_pump.sensor_fixed_target_flow_temperature import OctopusEnergyHeatPumpSensorFixedTargetFlowTemperature
 from .api_client.intelligent_device import IntelligentDevice
 from .intelligent.current_state import OctopusEnergyIntelligentCurrentState
 from .intelligent import get_intelligent_features
@@ -598,6 +599,13 @@ def setup_heat_pump_sensors(hass: HomeAssistant, account_id: str, heat_pump_id:
     entities.append(OctopusEnergyHeatPumpDataLastRetrieved(hass, coordinator, account_id, heat_pump_id))
 
   if heat_pump_response.octoHeatPumpControllerConfiguration is not None:
+    entities.append(OctopusEnergyHeatPumpSensorFixedTargetFlowTemperature(
+        hass,
+        coordinator,
+        heat_pump_id,
+        heat_pump_response.octoHeatPumpControllerConfiguration.heatPump
+      ))
+
     for zone in heat_pump_response.octoHeatPumpControllerConfiguration.zones:
       if zone.configuration is not None and zone.configuration.sensors is not None:
         if zone.configuration.enabled == False: