Update daikin integration

src/components/daikin/const.py

@@ -1,40 +1,86 @@
 """Constants for Daikin."""
-from homeassistant.const import CONF_ICON, CONF_NAME, CONF_TYPE
+from homeassistant.const import (
+    CONF_DEVICE_CLASS,
+    CONF_ICON,
+    CONF_NAME,
+    CONF_TYPE,
+    CONF_UNIT_OF_MEASUREMENT,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    ENERGY_KILO_WATT_HOUR,
+    POWER_KILO_WATT,
+    TEMP_CELSIUS,
+    UNIT_PERCENTAGE,
+)
 
 ATTR_TARGET_TEMPERATURE = "target_temperature"
 ATTR_INSIDE_TEMPERATURE = "inside_temperature"
 ATTR_OUTSIDE_TEMPERATURE = "outside_temperature"
+ATTR_TOTAL_POWER = "total_power"
+ATTR_COOL_ENERGY = "cool_energy"
+ATTR_HEAT_ENERGY = "heat_energy"
 
 ATTR_STATE_ON = "on"
 ATTR_STATE_OFF = "off"
 
 SENSOR_TYPE_TEMPERATURE = "temperature"
 SENSOR_TYPE_HUMIDITY = "humidity"
+SENSOR_TYPE_POWER = "power"
+SENSOR_TYPE_ENERGY = "energy"
 
 SENSOR_TYPES = {
     ATTR_INSIDE_TEMPERATURE: {
         CONF_NAME: "Inside Temperature",
-        CONF_ICON: "mdi:thermometer",
         CONF_TYPE: SENSOR_TYPE_TEMPERATURE,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_TEMPERATURE,
+        CONF_UNIT_OF_MEASUREMENT: TEMP_CELSIUS,
     },
     ATTR_OUTSIDE_TEMPERATURE: {
         CONF_NAME: "Outside Temperature",
-        CONF_ICON: "mdi:thermometer",
         CONF_TYPE: SENSOR_TYPE_TEMPERATURE,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_TEMPERATURE,
+        CONF_UNIT_OF_MEASUREMENT: TEMP_CELSIUS,
     },
     "hhum": {
         CONF_NAME: "Humidity",
         CONF_ICON: "mdi:percent",
         CONF_TYPE: SENSOR_TYPE_HUMIDITY,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_HUMIDITY,
+        CONF_UNIT_OF_MEASUREMENT: UNIT_PERCENTAGE,
     },
     "shum": {
         CONF_NAME: "Target Humidity",
         CONF_ICON: "mdi:percent",
         CONF_TYPE: SENSOR_TYPE_HUMIDITY,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_HUMIDITY,
+        CONF_UNIT_OF_MEASUREMENT: UNIT_PERCENTAGE,
+    },
+    ATTR_TOTAL_POWER: {
+        CONF_NAME: "Total Power Consumption",
+        CONF_TYPE: SENSOR_TYPE_POWER,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_POWER,
+        CONF_UNIT_OF_MEASUREMENT: POWER_KILO_WATT,
+    },
+    ATTR_COOL_ENERGY: {
+        CONF_NAME: "Cool Energy Consumption",
+        CONF_TYPE: SENSOR_TYPE_ENERGY,
+        CONF_ICON: "mdi:snowflake",
+        CONF_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR,
+    },
+    ATTR_HEAT_ENERGY: {
+        CONF_NAME: "Heat Energy Consumption",
+        CONF_TYPE: SENSOR_TYPE_ENERGY,
+        CONF_ICON: "mdi:fire",
+        CONF_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR,
     },
 }
 
+CONF_KEY = "key"
+CONF_UUID = "uuid"
+
 KEY_MAC = "mac"
 KEY_IP = "ip"
+KEY_HOSTNAME = "hostname"
 
 TIMEOUT = 60

src/components/daikin/sensor.py

@@ -1,11 +1,28 @@
 """Support for Daikin AC sensors."""
 import logging
 
-from homeassistant.const import CONF_ICON, CONF_NAME, CONF_TYPE, TEMP_CELSIUS, UNIT_PERCENTAGE
+from homeassistant.const import (
+    CONF_DEVICE_CLASS,
+    CONF_ICON,
+    CONF_NAME,
+    CONF_TYPE,
+    CONF_UNIT_OF_MEASUREMENT,
+)
 from homeassistant.helpers.entity import Entity
 
-from . import DOMAIN as DAIKIN_DOMAIN
+from . import DOMAIN as DAIKIN_DOMAIN, DaikinApi
-from .const import ATTR_INSIDE_TEMPERATURE, ATTR_OUTSIDE_TEMPERATURE, SENSOR_TYPES, SENSOR_TYPE_HUMIDITY
+from .const import (
+    ATTR_COOL_ENERGY,
+    ATTR_HEAT_ENERGY,
+    ATTR_INSIDE_TEMPERATURE,
+    ATTR_OUTSIDE_TEMPERATURE,
+    ATTR_TOTAL_POWER,
+    SENSOR_TYPE_ENERGY,
+    SENSOR_TYPE_POWER,
+    SENSOR_TYPE_TEMPERATURE,
+    SENSOR_TYPE_HUMIDITY,
+    SENSOR_TYPES,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,19 +41,31 @@ async def async_setup_entry(hass, entry, async_add_entities):
     sensors = [ATTR_INSIDE_TEMPERATURE]
     if daikin_api.device.support_outside_temperature:
         sensors.append(ATTR_OUTSIDE_TEMPERATURE)
-
+    if daikin_api.device.support_energy_consumption:
+        sensors.append(ATTR_TOTAL_POWER)
+        sensors.append(ATTR_COOL_ENERGY)
+        sensors.append(ATTR_HEAT_ENERGY)
     if daikin_api.device.values.get("hhum").replace("-", ""):
         sensors.append("hhum")
         sensors.append("shum")
-
+    async_add_entities([DaikinSensor.factory(daikin_api, sensor) for sensor in sensors])
-    async_add_entities([DaikinClimateSensor(daikin_api, sensor) for sensor in sensors])
 
 
-
+class DaikinSensor(Entity):
-class DaikinClimateSensor(Entity):
     """Representation of a Sensor."""
 
-    def __init__(self, api, monitored_state) -> None:
+    @staticmethod
+    def factory(api: DaikinApi, monitored_state: str):
+        """Initialize any DaikinSensor."""
+        cls = {
+            SENSOR_TYPE_TEMPERATURE: DaikinClimateSensor,
+            SENSOR_TYPE_HUMIDITY: DaikinClimateSensor,
+            SENSOR_TYPE_POWER: DaikinPowerSensor,
+            SENSOR_TYPE_ENERGY: DaikinPowerSensor,
+        }[SENSOR_TYPES[monitored_state][CONF_TYPE]]
+        return cls(api, monitored_state)
+
+    def __init__(self, api: DaikinApi, monitored_state: str) -> None:
         """Initialize the sensor."""
         self._api = api
         self._sensor = SENSOR_TYPES[monitored_state]
@@ -46,12 +75,7 @@ class DaikinClimateSensor(Entity):
     @property
     def unique_id(self):
         """Return a unique ID."""
-        return f"{self._api.mac}-{self._device_attribute}"
+        return f"{self._api.device.mac}-{self._device_attribute}"
-
-    @property
-    def icon(self):
-        """Icon to use in the frontend, if any."""
-        return self._sensor[CONF_ICON]
 
     @property
     def name(self):
@@ -61,22 +85,22 @@ class DaikinClimateSensor(Entity):
     @property
     def state(self):
         """Return the state of the sensor."""
-        if self._device_attribute == "hhum":
+        raise NotImplementedError
-            return int(self._api.device.values.get("hhum").replace("-", "0"))
+
-        if self._device_attribute == "bhum":
+    @property
-            return int(self._api.device.values.get("bhum").replace("-", "0"))
+    def device_class(self):
-        if self._device_attribute == ATTR_INSIDE_TEMPERATURE:
+        """Return the class of this device."""
-            return self._api.device.inside_temperature
+        return self._sensor.get(CONF_DEVICE_CLASS)
-        if self._device_attribute == ATTR_OUTSIDE_TEMPERATURE:
+
-            return self._api.device.outside_temperature
+    @property
-        return None
+    def icon(self):
+        """Return the icon of this device."""
+        return self._sensor.get(CONF_ICON)
 
     @property
     def unit_of_measurement(self):
         """Return the unit of measurement."""
-        if self._sensor[CONF_TYPE] == SENSOR_TYPE_HUMIDITY:
+        return self._sensor[CONF_UNIT_OF_MEASUREMENT]
-            return UNIT_PERCENTAGE
-        return TEMP_CELSIUS
 
     async def async_update(self):
         """Retrieve latest state."""
@@ -86,3 +110,36 @@ class DaikinClimateSensor(Entity):
     def device_info(self):
         """Return a device description for device registry."""
         return self._api.device_info
+
+
+class DaikinClimateSensor(DaikinSensor):
+    """Representation of a Climate Sensor."""
+
+    @property
+    def state(self):
+        """Return the internal state of the sensor."""
+        if self._device_attribute == ATTR_INSIDE_TEMPERATURE:
+            return self._api.device.inside_temperature
+        if self._device_attribute == ATTR_OUTSIDE_TEMPERATURE:
+            return self._api.device.outside_temperature
+
+        if self._device_attribute == "hhum":
+            return int(self._api.device.values.get("hhum").replace("-", "0"))
+        if self._device_attribute == "bhum":
+            return int(self._api.device.values.get("bhum").replace("-", "0"))
+        return None
+
+
+class DaikinPowerSensor(DaikinSensor):
+    """Representation of a power/energy consumption sensor."""
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        if self._device_attribute == ATTR_TOTAL_POWER:
+            return round(self._api.device.current_total_power_consumption, 3)
+        if self._device_attribute == ATTR_COOL_ENERGY:
+            return round(self._api.device.last_hour_cool_energy_consumption, 3)
+        if self._device_attribute == ATTR_HEAT_ENERGY:
+            return round(self._api.device.last_hour_heat_energy_consumption, 3)
+        return None