Merge pull request #74 from plugwise/up111_3

Upstreaming PR #36219 second batch of changes

Author: bouwew

custom_components/plugwise-beta/__init__.py

@@ -5,19 +5,19 @@
 from datetime import timedelta
 from typing import Dict
 
-from Plugwise_Smile.Smile import Smile
 import async_timeout
 import voluptuous as vol
+from Plugwise_Smile.Smile import Smile
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant 
+from homeassistant.core import HomeAssistant, callback
 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.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import DOMAIN, THERMOSTAT_ICON
+from .const import DOMAIN
 
 CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({})}, extra=vol.ALLOW_EXTRA)
 
@@ -43,7 +43,6 @@ async def async_setup_entry(hass, entry):
         connected = await api.connect()
 
         if not connected:
-            _LOGGER.error("Unable to connect to Smile: %s",api.smile_status)
             raise ConfigEntryNotReady
 
     except Smile.InvalidAuthentication:
@@ -73,15 +72,15 @@ async def async_update_data():
                 return True
         except Smile.XMLDataMissingError:
             _LOGGER.debug("Updating Smile failed %s", api.smile_type)
-            raise UpdateFailed("Smile update failed %s", api.smile_type)
-
+            raise UpdateFailed("Smile update failed")
 
     coordinator = DataUpdateCoordinator(
         hass,
         _LOGGER,
         name="Smile",
         update_method=async_update_data,
-        update_interval=update_interval)
+        update_interval=update_interval,
+    )
 
     await coordinator.async_refresh()
 
@@ -92,7 +91,10 @@ async def async_update_data():
 
     _LOGGER.debug("Async update interval %s", update_interval)
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = { "api": api, "coordinator": coordinator }
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
+        "api": api,
+        "coordinator": coordinator,
+    }
 
     _LOGGER.debug("Gateway is %s", api.gateway_id)
 
@@ -111,9 +113,10 @@ async def async_update_data():
         sw_version=api.smile_version[0],
     )
 
+    platforms = ALL_PLATFORMS
+
     single_master_thermostat = api.single_master_thermostat()
     _LOGGER.debug("Single master thermostat = %s", single_master_thermostat)
-    platforms = ALL_PLATFORMS
     if single_master_thermostat is None:
         platforms = SENSOR_PLATFORMS
 
@@ -144,16 +147,17 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
 class SmileGateway(Entity):
     """Represent Smile Gateway."""
 
-    def __init__(self, api, coordinator):
+    def __init__(self, api, coordinator, name, dev_id):
         """Initialise the gateway."""
         self._api = api
         self._coordinator = coordinator
+        self._name = name
+        self._dev_id = dev_id
+
         self._unique_id = None
-        self._name = None
-        self._icon = None
-        self._dev_id = None
         self._model = None
-        self._gateway_id = None
+
+        self._entity_name = self._name
 
     @property
     def unique_id(self):
@@ -177,43 +181,35 @@ def name(self):
             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,
+            "name": self._entity_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)
+        if self._dev_id != self._api.gateway_id:
+            device_information["via_device"] = (DOMAIN, self._api.gateway_id)
 
         return device_information
 
     async def async_added_to_hass(self):
         """Subscribe to updates."""
-        self._process_data()
+        self._async_process_data()
         self.async_on_remove(
-            self._coordinator.async_add_listener(self._process_data)
+            self._coordinator.async_add_listener(self._async_process_data)
         )
-    
-    def _process_data(self):
+
+    @callback
+    def _async_process_data(self):
         """Interpret and process API data."""
         raise NotImplementedError
 
     async def async_update(self):
         """Update the entity."""
         await self._coordinator.async_request_refresh()
-

custom_components/plugwise-beta/binary_sensor.py

@@ -1,29 +1,18 @@
 """Plugwise Binary Sensor component for Home Assistant."""
 
 import logging
-from typing import Dict
 
-from homeassistant.components.binary_sensor import (
-    DEVICE_CLASS_OPENING,
-    BinarySensorEntity,
-)
+from homeassistant.components.binary_sensor import BinarySensorEntity, DEVICE_CLASS_OPENING
 from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import callback
 
-from .const import (
-    DOMAIN,
-    FLAME_ICON,    
-    VALVE_CLOSED_ICON,
-    VALVE_OPEN_ICON,
-    WATER_ICON,
-)
-
+from .const import DOMAIN, FLOW_OFF_ICON, FLOW_ON_ICON, IDLE_ICON, FLAME_ICON
 from .sensor import SmileSensor
 
-BINARY_SENSOR_LIST = [
-    "dhw_state",
-    "slave_boiler_state",
-    "valve_position",
-]
+BINARY_SENSOR_MAP = {
+    "dhw_state": ["Domestic Hot Water State", None],
+    "slave_boiler_state": ["Secondary Heater Device State", None],
+}
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,59 +22,45 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     api = hass.data[DOMAIN][config_entry.entry_id]["api"]
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
-    devices = []
-    binary_sensor_classes = [
-        "heater_central",
-        "thermo_sensor",
-        "thermostatic_radiator_valve",
-    ]
+    entities = []
+
     all_devices = api.get_all_devices()
-    for dev_id, device in all_devices.items():
-        if device["class"] in binary_sensor_classes:
-            _LOGGER.debug("Plugwise device_class %s found", device["class"])
+    for dev_id, device_properties in all_devices.items():
+        if device_properties["class"] == "heater_central":
+            _LOGGER.debug("Plugwise device_class %s found", device_properties["class"])
             data = api.get_device_data(dev_id)
-            for binary_sensor in BINARY_SENSOR_LIST:
+            for binary_sensor, b_s_type in BINARY_SENSOR_MAP.items():
                 _LOGGER.debug("Binary_sensor: %s", binary_sensor)
                 if binary_sensor in data:
-                    _LOGGER.debug("Plugwise binary_sensor Dev %s", device["name"])
-                    devices.append(
+                    _LOGGER.debug(
+                        "Plugwise binary_sensor Dev %s", device_properties["name"]
+                    )
+                    entities.append(
                         PwBinarySensor(
                             api,
                             coordinator,
-                            device["name"],
+                            device_properties["name"],
                             binary_sensor,
                             dev_id,
-                            device["class"],
+                            device_properties["class"],
                         )
                     )
-                    _LOGGER.info("Added binary_sensor.%s", device["name"])
+                    _LOGGER.info("Added binary_sensor.%s", device_properties["name"])
 
-    async_add_entities(devices, True)
+    async_add_entities(entities, True)
 
 
 class PwBinarySensor(SmileSensor, BinarySensorEntity):
     """Representation of a Plugwise binary_sensor."""
 
     def __init__(self, api, coordinator, name, binary_sensor, dev_id, model):
         """Set up the Plugwise API."""
-        super().__init__(api, coordinator)
+        super().__init__(api, coordinator, name, dev_id, binary_sensor)
 
-        self._api = api
-        self._dev_id = dev_id
-        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._entity_name = f"Auxiliary"
-
-        if self._dev_id == self._api.gateway_id:
-            self._entity_name = f"Smile {self._name}"
 
-        bsensorname = binary_sensor.replace("_", " ").title()
-        self._name = f"{self._entity_name} {bsensorname}"
+        self._is_on = False
+        self._icon = None
 
         self._unique_id = f"bs-{dev_id}-{self._entity_name}-{binary_sensor}"
 
@@ -94,32 +69,35 @@ def is_on(self):
         """Return true if the binary sensor is on."""
         return self.is_on
 
-    def _process_data(self):
+    @property
+    def icon(self):
+        """Return the icon to use in the frontend."""
+        return self._icon
+
+    @callback
+    def _async_process_data(self):
         """Update the entity."""
         _LOGGER.debug("Update binary_sensor called")
         data = self._api.get_device_data(self._dev_id)
 
         if not data:
             _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
-
+            self.async_write_ha_state()
+            return
+
+        if self._binary_sensor in data:
+            self._is_on = data[self._binary_sensor]
+
+            self._state = STATE_OFF
+            if self._binary_sensor == "dhw_state":
+                self._icon = FLOW_OFF_ICON
+            if self._binary_sensor == "slave_boiler_state":
+                self._icon = IDLE_ICON
+            if self._is_on:
+                self._state = STATE_ON
                 if self._binary_sensor == "dhw_state":
-                    self._icon = WATER_ICON
+                    self._icon = FLOW_ON_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()
+        self.async_write_ha_state()