Merge pull request #72 from plugwise/up111_2

Upstreaming PR #36219 first changes

Author: bouwew

custom_components/plugwise-beta/__init__.py

@@ -3,22 +3,21 @@
 import asyncio
 import logging
 from datetime import timedelta
-from typing import Optional
-import voluptuous as vol
+from typing import Dict
 
+from Plugwise_Smile.Smile import Smile
 import async_timeout
+import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant 
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from Plugwise_Smile.Smile import Smile
 
-from .const import DOMAIN
+from .const import DOMAIN, THERMOSTAT_ICON
 
 CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({})}, extra=vol.ALLOW_EXTRA)
 
@@ -27,6 +26,7 @@
 SENSOR_PLATFORMS = ["sensor"]
 ALL_PLATFORMS = ["binary_sensor", "climate", "sensor", "switch"]
 
+
 async def async_setup(hass: HomeAssistant, config: dict):
     """Set up the Plugwise platform."""
     return True
@@ -76,8 +76,6 @@ async def async_update_data():
             raise UpdateFailed("Smile update failed %s", api.smile_type)
 
 
-    api.get_all_devices()
-
     coordinator = DataUpdateCoordinator(
         hass,
         _LOGGER,
@@ -87,6 +85,8 @@ async def async_update_data():
 
     await coordinator.async_refresh()
 
+    api.get_all_devices()
+
     if not coordinator.last_update_success:
         raise ConfigEntryNotReady
 
@@ -145,10 +145,15 @@ class SmileGateway(Entity):
     """Represent Smile Gateway."""
 
     def __init__(self, api, coordinator):
-        """Initialise the sensor."""
+        """Initialise the gateway."""
         self._api = api
         self._coordinator = coordinator
         self._unique_id = None
+        self._name = None
+        self._icon = None
+        self._dev_id = None
+        self._model = None
+        self._gateway_id = None
 
     @property
     def unique_id(self):
@@ -165,8 +170,41 @@ def available(self):
         """Return True if entity is available."""
         return self._coordinator.last_update_success
 
+    @property
+    def name(self):
+        """Return the name of the entity, if any."""
+        if not self._name:
+            pass
+        return self._name
+
+    @property
+    def icon(self):
+        """Return the icon to use in the frontend."""
+        if not self._icon:
+            return THERMOSTAT_ICON
+        return self._icon
+
+    @property
+    def device_info(self) -> Dict[str, any]:
+        """Return the device information."""
+
+        device_information = {
+            "identifiers": {(DOMAIN, self._dev_id)},
+            "name": self._name,
+            "manufacturer": "Plugwise",
+        }
+
+        if self._model is not None:
+            device_information["model"] = self._model.replace("_", " ").title()
+
+        if self._dev_id != self._gateway_id:
+            device_information["via_device"] = (DOMAIN, self._gateway_id)
+
+        return device_information
+
     async def async_added_to_hass(self):
         """Subscribe to updates."""
+        self._process_data()
         self.async_on_remove(
             self._coordinator.async_add_listener(self._process_data)
         )
@@ -178,3 +216,4 @@ def _process_data(self):
     async def async_update(self):
         """Update the entity."""
         await self._coordinator.async_request_refresh()
+

custom_components/plugwise-beta/binary_sensor.py

@@ -17,7 +17,7 @@
     WATER_ICON,
 )
 
-from . import SmileGateway
+from .sensor import SmileSensor
 
 BINARY_SENSOR_LIST = [
     "dhw_state",
@@ -63,7 +63,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     async_add_entities(devices, True)
 
 
-class PwBinarySensor(SmileGateway, BinarySensorEntity):
+class PwBinarySensor(SmileSensor, BinarySensorEntity):
     """Representation of a Plugwise binary_sensor."""
 
     def __init__(self, api, coordinator, name, binary_sensor, dev_id, model):
@@ -72,74 +72,28 @@ def __init__(self, api, coordinator, name, binary_sensor, dev_id, model):
 
         self._api = api
         self._dev_id = dev_id
-        self._model = model
-        self._name = name
+        self._entity_name = name
         self._binary_sensor = binary_sensor
         self._is_on = False
+        self._state = None
+        self._dev_class = None
 
         if self._dev_id == self._api.heater_id:
-            self._name = f"Auxiliary"
+            self._entity_name = f"Auxiliary"
 
         if self._dev_id == self._api.gateway_id:
-            self._name = f"Smile {self._name}"
+            self._entity_name = f"Smile {self._name}"
 
         bsensorname = binary_sensor.replace("_", " ").title()
-        self._sensorname = f"{self._name} {bsensorname}"
+        self._name = f"{self._entity_name} {bsensorname}"
 
-        self._unique_id = f"bs-{dev_id}-{self._name}-{binary_sensor}"
-
-    @property
-    def name(self):
-        """Return the name of the thermostat, if any."""
-        return self._sensorname
+        self._unique_id = f"bs-{dev_id}-{self._entity_name}-{binary_sensor}"
 
     @property
     def is_on(self):
         """Return true if the binary sensor is on."""
         return self.is_on
 
-    @property
-    def state(self):
-        """Return the state of the binary sensor."""
-        if self._is_on:
-            return STATE_ON
-        return STATE_OFF
-
-    @property
-    def device_info(self) -> Dict[str, any]:
-        """Return the device information."""
-
-        device_information = {
-            "identifiers": {(DOMAIN, self._dev_id)},
-            "name": self._name,
-            "manufacturer": "Plugwise",
-            "model": self._model,
-        }
-
-        if self._dev_id != self._api.gateway_id:
-            device_information["via_device"] = (DOMAIN, self._api.gateway_id)
-
-        return device_information
-
-    @property
-    def icon(self):
-        """Return the icon to use in the frontend."""
-        if self._binary_sensor == "dhw_state":
-            return WATER_ICON
-        if self._binary_sensor == "slave_boiler_state":
-            return FLAME_ICON
-        if self._binary_sensor == "valve_position":
-            if self._is_on:
-                return VALVE_OPEN_ICON
-            return VALVE_CLOSED_ICON
-
-    @property
-    def device_class(self):
-        """Return the class of this device, from component DEVICE_CLASSES."""
-        if self._binary_sensor == "valve_position":
-            return DEVICE_CLASS_OPENING
-        return "none"
-
     def _process_data(self):
         """Update the entity."""
         _LOGGER.debug("Update binary_sensor called")
@@ -149,8 +103,23 @@ def _process_data(self):
             _LOGGER.error("Received no data for device %s.", self._binary_sensor)
         else:
             if self._binary_sensor in data:
+                self._state = STATE_OFF
+
                 if isinstance(data[self._binary_sensor], float):
                     self._is_on = data[self._binary_sensor] == 1.0
                 self._is_on = data[self._binary_sensor]
 
+                if self._is_on:
+                    self._state = STATE_ON
+
+                if self._binary_sensor == "dhw_state":
+                    self._icon = WATER_ICON
+                if self._binary_sensor == "slave_boiler_state":
+                    self._icon = FLAME_ICON
+                if self._binary_sensor == "valve_position":
+                    self._dev_class = DEVICE_CLASS_OPENING
+                    self._icon = VALVE_CLOSED_ICON
+                    if self._is_on:
+                        self._icon = VALVE_OPEN_ICON
+
         self.async_write_ha_state()

custom_components/plugwise-beta/climate.py

@@ -1,7 +1,6 @@
 """Plugwise Climate component for Home Assistant."""
 
 import logging
-from typing import Dict
 from Plugwise_Smile.Smile import Smile
 
 from homeassistant.components.climate import ClimateEntity
@@ -84,6 +83,7 @@ def __init__(self, api, coordinator, name, dev_id, loc_id, model, min_temp, max_
         super().__init__(api, coordinator)
 
         self._api = api
+        self._gateway_id = self._api.gateway_id
         self._name = name
         self._dev_id = dev_id
         self._loc_id = loc_id
@@ -96,9 +96,9 @@ def __init__(self, api, coordinator, name, dev_id, loc_id, model, min_temp, max_
         self._preset_mode = None
         self._presets = None
         self._presets_list = None
-        self._boiler_state = None
         self._heating_state = None
         self._cooling_state = None
+        self._compressor_state = None
         self._dhw_state = None
         self._hvac_mode = None
         self._schema_names = None
@@ -109,48 +109,23 @@ def __init__(self, api, coordinator, name, dev_id, loc_id, model, min_temp, max_
         self._schedule_temp = None
         self._hvac_mode = None
         self._single_thermostat = self._api.single_master_thermostat()
+        self._icon = THERMOSTAT_ICON
         self._unique_id = f"cl-{dev_id}-{self._name}"
 
     @property
     def hvac_action(self):
         """Return the current action."""
         if self._single_thermostat:
-            if self._heating_state or self._boiler_state:
+            if self._heating_state:
                 return CURRENT_HVAC_HEAT
             if self._cooling_state:
                 return CURRENT_HVAC_COOL
             return CURRENT_HVAC_IDLE
-        if self._heating_state is not None or self._boiler_state is not None:
+        if self._heating_state is not None:
             if self._setpoint > self._temperature:
                 return CURRENT_HVAC_HEAT
             return CURRENT_HVAC_IDLE
 
-    @property
-    def name(self):
-        """Return the name of the thermostat, if any."""
-        return self._name
-
-    @property
-    def device_info(self) -> Dict[str, any]:
-        """Return the device information."""
-
-        device_information = {
-            "identifiers": {(DOMAIN, self._dev_id)},
-            "name": self._name,
-            "manufacturer": "Plugwise",
-            "model": self._model.replace("_", " ").title(),
-        }
-
-        if self._dev_id != self._api.gateway_id:
-            device_information["via_device"] = (DOMAIN, self._api.gateway_id)
-
-        return device_information
-
-    @property
-    def icon(self):
-        """Return the icon to use in the frontend."""
-        return THERMOSTAT_ICON
-
     @property
     def supported_features(self):
         """Return the list of supported features."""
@@ -174,8 +149,8 @@ def preset_modes(self):
     @property
     def hvac_modes(self):
         """Return the available hvac modes list."""
-        if self._heating_state is not None or self._boiler_state is not None:
-            if self._cooling_state is not None:
+        if self._heating_state is not None:
+            if self._compressor_state is not None:
                 return HVAC_MODES_HEAT_COOL
             return HVAC_MODES_HEAT_ONLY
 
@@ -300,21 +275,18 @@ def _process_data(self):
             _LOGGER.error("Received no heater_central_data for device %s.", self._name)
         else:
             _LOGGER.debug("Heater_central_data collected from Plugwise API")
-            if "boiler_state" in heater_central_data:
-                if heater_central_data["boiler_state"] is not None:
-                    self._boiler_state = heater_central_data["boiler_state"]
-            if "heating_state" in heater_central_data:
-                if heater_central_data["heating_state"] is not None:
-                    self._heating_state = heater_central_data["heating_state" ]
-            if "cooling_state" in heater_central_data:
-                if heater_central_data["cooling_state"] is not None:
-                    self._cooling_state = heater_central_data["cooling_state"]
+            if heater_central_data.get("heating_state") is not None:
+                self._heating_state = heater_central_data["heating_state"]
+            if heater_central_data.get("cooling_state") is not None:
+                self._cooling_state = heater_central_data["cooling_state"]
+            if heater_central_data.get("compressor_state") is not None:
+                self._compressor_state = heater_central_data["compressor_state"]
 
         if self._schema_status:
             self._hvac_mode = HVAC_MODE_AUTO
-        elif self._heating_state is not None or self._boiler_state is not None:
+        elif self._heating_state is not None:
             self._hvac_mode = HVAC_MODE_HEAT
-            if self._cooling_state is not None:
+            if self._compressor_state is not None:
                 self._hvac_mode = HVAC_MODE_HEAT_COOL
 
         self.async_write_ha_state()

custom_components/plugwise-beta/const.py

@@ -24,9 +24,9 @@
 CONF_SOLAR = "solar"
 CONF_GAS = "gas"
 
-ATTR_ILLUMINANCE = "illuminance"
 CURRENT_HVAC_DHW = "hot_water"
 DEVICE_STATE = "device_state"
+UNIT_LUMEN  = "lm"
 
 SCHEDULE_ON = "true"
 SCHEDULE_OFF = "false"

custom_components/plugwise-beta/manifest.json

@@ -2,8 +2,7 @@
   "domain": "plugwise-beta",
   "name": "Plugwise Beta for Home Assistant",
   "documentation": "https://github.com/plugwise/plugwise-beta",
-  "requirements": ["Plugwise_Smile==0.2.12"],
-  "dependencies": [],
+  "requirements": ["Plugwise_Smile==0.2.13"],
   "codeowners": ["@CoMPaTech","@bouwew"],
   "config_flow": true
 }