Merge pull request #59 from plugwise/DataUpdater

First working attempt at dataupdater

Author: bouwew

custom_components/plugwise-beta/__init__.py

@@ -6,12 +6,16 @@
 from typing import Optional
 import voluptuous as vol
 
+import async_timeout
+
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import PlatformNotReady
+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
@@ -23,13 +27,12 @@
 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
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass, entry):
     """Set up Plugwise Smiles from a config entry."""
     websession = async_get_clientsession(hass, verify_ssl=False)
     api = Smile(
@@ -56,16 +59,36 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     else:
         update_interval = timedelta(seconds=60)
 
+    async def async_update_data():
+        """Update data via API endpoint."""
+        _LOGGER.debug("Updating Smile %s", api.smile_type)
+        try:
+            async with async_timeout.timeout(10):
+                await api.full_update_device()
+                _LOGGER.debug("Succesfully updated Smile %s", api.smile_type)
+                return True
+        except Smile.XMLDataMissingError:
+            _LOGGER.debug("Updating Smile failed %s", api.smile_type)
+            raise UpdateFailed("Smile update failed %s", api.smile_type)
+
+
     api.get_all_devices()
 
+    coordinator = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name="Smile",
+        update_method=async_update_data,
+        update_interval=update_interval)
+
+    await coordinator.async_refresh()
+
+    if not coordinator.last_update_success:
+        raise ConfigEntryNotReady
+
     _LOGGER.debug("Async update interval %s", update_interval)
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
-        "api": api,
-        "updater": SmileDataUpdater(
-            hass, "device", entry.entry_id, api, "full_update_device", update_interval
-        ),
-    }
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = { "api": api, "coordinator": coordinator }
 
     _LOGGER.debug("Gateway is %s", api.gateway_id)
 
@@ -95,13 +118,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             hass.config_entries.async_forward_entry_setup(entry, component)
         )
 
-    async def async_refresh_all(_):
-        """Refresh all Smile data."""
-        for info in hass.data[DOMAIN].values():
-            await info["updater"].async_refresh_all()
-
-    hass.services.async_register(DOMAIN, "update", async_refresh_all)
-
     return True
 
 
@@ -121,61 +137,34 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
     return unload_ok
 
 
-class SmileDataUpdater:
-    """Data storage for single Smile API endpoint."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        data_type: str,
-        config_entry_id: str,
-        api: Smile,
-        update_method: str,
-        update_interval: timedelta,
-    ):
-        """Initialize global data updater."""
-        self.hass = hass
-        self.data_type = data_type
-        self.config_entry_id = config_entry_id
-        self.api = api
-        self.update_method = update_method
-        self.update_interval = update_interval
-        self.listeners = []
-        self._unsub_interval = None
-
-    @callback
-    def async_add_listener(self, update_callback):
-        """Listen for data updates."""
-        if not self.listeners:
-            self._unsub_interval = async_track_time_interval(
-                self.hass, self.async_refresh_all, self.update_interval
-            )
-
-        self.listeners.append(update_callback)
-
-    @callback
-    def async_remove_listener(self, update_callback):
-        """Remove data update."""
-        self.listeners.remove(update_callback)
-
-        if not self.listeners:
-            self._unsub_interval()
-            self._unsub_interval = None
-
-    async def async_refresh_all(self, _now: Optional[int] = None) -> None:
-        """Time to update."""
-        _LOGGER.debug("Smile updating with interval: %s", self.update_interval)
-        if not self.listeners:
-            _LOGGER.error("Smile has no listeners, not updating")
-            return
-
-        _LOGGER.debug("Smile updating data using: %s", self.update_method)
+class SmileGateway(Entity):
+    """Represent Smile Gateway."""
 
-        try:
-            await self.api.full_update_device()
-        except Smile.XMLDataMissingError as e:
-            _LOGGER.error("Smile update failed")
-            raise e
+    def __init__(self, api, coordinator):
+        """Initialise the sensor."""
+        self._api = api
+        self._coordinator = coordinator
 
-        for update_callback in self.listeners:
-            update_callback()
+    @property
+    def should_poll(self):
+        """Return False, updates are controlled via coordinator."""
+        return False
+
+    @property
+    def available(self):
+        """Return True if entity is available."""
+        return self._coordinator.last_update_success
+
+    async def async_added_to_hass(self):
+        """Subscribe to updates."""
+        self.async_on_remove(
+            self._coordinator.async_add_listener(self._process_data)
+        )
+    
+    def _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

@@ -7,9 +7,7 @@
     DEVICE_CLASS_OPENING,
     BinarySensorDevice,
 )
-
 from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import callback
 
 from .const import (
     DOMAIN,
@@ -19,6 +17,8 @@
     WATER_ICON,
 )
 
+from . import SmileGateway
+
 BINARY_SENSOR_LIST = [
     "dhw_state",
     "slave_boiler_state",
@@ -31,7 +31,7 @@
 async def async_setup_entry(hass, config_entry, async_add_entities):
     """Set up the Smile binary_sensors from a config entry."""
     api = hass.data[DOMAIN][config_entry.entry_id]["api"]
-    updater = hass.data[DOMAIN][config_entry.entry_id]["updater"]
+    coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
     devices = []
     binary_sensor_classes = [
@@ -51,7 +51,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
                     devices.append(
                         PwBinarySensor(
                             api,
-                            updater,
+                            coordinator,
                             device["name"],
                             binary_sensor,
                             dev_id,
@@ -63,13 +63,14 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     async_add_entities(devices, True)
 
 
-class PwBinarySensor(BinarySensorDevice):
+class PwBinarySensor(SmileGateway, BinarySensorDevice):
     """Representation of a Plugwise binary_sensor."""
 
-    def __init__(self, api, updater, name, binary_sensor, dev_id, model):
+    def __init__(self, api, coordinator, name, binary_sensor, dev_id, model):
         """Set up the Plugwise API."""
+        super().__init__(api, coordinator)
+
         self._api = api
-        self._updater = updater
         self._dev_id = dev_id
         self._model = model
         self._name = name
@@ -94,30 +95,11 @@ def unique_id(self):
         """Return a unique ID."""
         return self._unique_id
 
-    async def async_added_to_hass(self):
-        """Register callbacks."""
-        self._updater.async_add_listener(self._update_callback)
-
-    async def async_will_remove_from_hass(self):
-        """Disconnect callbacks."""
-        self._updater.async_remove_listener(self._update_callback)
-
-    @callback
-    def _update_callback(self):
-        """Call update method."""
-        self.update()
-        self.async_write_ha_state()
-
     @property
     def name(self):
         """Return the name of the thermostat, if any."""
         return self._sensorname
 
-    @property
-    def should_poll(self):
-        """No need to poll. Coordinator notifies entity of updates."""
-        return False
-
     @property
     def is_on(self):
         """Return true if the binary sensor is on."""
@@ -160,7 +142,7 @@ def device_class(self):
             return DEVICE_CLASS_OPENING
         return "none"
 
-    def update(self):
+    def _process_data(self):
         """Update the entity."""
         _LOGGER.debug("Update binary_sensor called")
         data = self._api.get_device_data(self._dev_id)
@@ -172,3 +154,5 @@ def update(self):
                 if isinstance(data[self._binary_sensor], float):
                     self._is_on = data[self._binary_sensor] == 1.0
                 self._is_on = data[self._binary_sensor]
+
+        self.async_write_ha_state()