Reimplement PGLab sensor to use a coordinator (home-assistant#139789)

* Reimplement PGLab sensor to use a coordinator

* fix spelling mistake on coordinator name

* rename createDiscoverDeviceInfo function in snake_case

* adding suffix pglab_ to PGLabBaseEntity/PGLabEntity constructor parameters

* Fix docs of PGLabEntity::async_added_to_hass

* make coordinator able to return the sensor native value

* renaming PGLABConfigEntry in PGLabConfigEntry to be consistent with the integration naming

* renamed entry function arguments to config_entry to be less confusing

* pass config_entry to constructor of base class of PGLabSensorsCoordinator

* set the return value type of get_sensor_value

* store coordinator as regular instance attribute

* Avoid to access directly entity from discovery module

* Rearrange get_sensor_value return types

Author: pglab-electronics

homeassistant/components/pglab/__init__.py

@@ -23,12 +23,14 @@
 from .const import DOMAIN, LOGGER
 from .discovery import PGLabDiscovery
 
-type PGLABConfigEntry = ConfigEntry[PGLabDiscovery]
+type PGLabConfigEntry = ConfigEntry[PGLabDiscovery]
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: PGLABConfigEntry) -> bool:
+async def async_setup_entry(
+    hass: HomeAssistant, config_entry: PGLabConfigEntry
+) -> bool:
     """Set up PG LAB Electronics integration from a config entry."""
 
     async def mqtt_publish(topic: str, payload: str, qos: int, retain: bool) -> None:
@@ -67,19 +69,21 @@ async def mqtt_unsubscribe(sub_state: PyPGLabSubState) -> None:
     pglab_mqtt = PyPGLabMqttClient(mqtt_publish, mqtt_subscribe, mqtt_unsubscribe)
 
     # Setup PGLab device discovery.
-    entry.runtime_data = PGLabDiscovery()
+    config_entry.runtime_data = PGLabDiscovery()
 
     # Start to discovery PG Lab devices.
-    await entry.runtime_data.start(hass, pglab_mqtt, entry)
+    await config_entry.runtime_data.start(hass, pglab_mqtt, config_entry)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: PGLABConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, config_entry: PGLabConfigEntry
+) -> bool:
     """Unload a config entry."""
 
     # Stop PGLab device discovery.
-    pglab_discovery = entry.runtime_data
-    await pglab_discovery.stop(hass, entry)
+    pglab_discovery = config_entry.runtime_data
+    await pglab_discovery.stop(hass, config_entry)
 
     return True

homeassistant/components/pglab/coordinator.py

@@ -0,0 +1,78 @@
+"""Coordinator for PG LAB Electronics."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+from pypglab.const import SENSOR_REBOOT_TIME, SENSOR_TEMPERATURE, SENSOR_VOLTAGE
+from pypglab.device import Device as PyPGLabDevice
+from pypglab.sensor import Sensor as PyPGLabSensors
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.util.dt import utcnow
+
+from .const import DOMAIN, LOGGER
+
+if TYPE_CHECKING:
+    from . import PGLabConfigEntry
+
+
+class PGLabSensorsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Class to update Sensor Entities when receiving new data."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: PGLabConfigEntry,
+        pglab_device: PyPGLabDevice,
+    ) -> None:
+        """Initialize."""
+
+        # get a reference of PG Lab device internal sensors state
+        self._sensors: PyPGLabSensors = pglab_device.sensors
+
+        super().__init__(
+            hass,
+            LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+        )
+
+    @callback
+    def _new_sensors_data(self, payload: str) -> None:
+        """Handle new sensor data."""
+
+        # notify all listeners that new sensor values are available
+        self.async_set_updated_data(self._sensors.state)
+
+    async def subscribe_topics(self) -> None:
+        """Subscribe the sensors state to be notifty from MQTT update messages."""
+
+        # subscribe to the pypglab sensors to receive updates from the mqtt broker
+        # when a new sensor values are available
+        await self._sensors.subscribe_topics()
+
+        # set the callback to be called when a new sensor values are available
+        self._sensors.set_on_state_callback(self._new_sensors_data)
+
+    def get_sensor_value(self, sensor_key: str) -> float | datetime | None:
+        """Return the value of a sensor."""
+
+        if self.data:
+            value = self.data[sensor_key]
+
+            if (sensor_key == SENSOR_REBOOT_TIME) and value:
+                # convert the reboot time to a datetime object
+                return utcnow() - timedelta(seconds=value)
+
+            if (sensor_key == SENSOR_TEMPERATURE) and value:
+                # convert the temperature value to a float
+                return float(value)
+
+            if (sensor_key == SENSOR_VOLTAGE) and value:
+                # convert the voltage value to a float
+                return float(value)
+
+        return None

homeassistant/components/pglab/device_sensor.py

@@ -25,13 +25,12 @@
     async_dispatcher_connect,
     async_dispatcher_send,
 )
-from homeassistant.helpers.entity import Entity
 
 from .const import DISCOVERY_TOPIC, DOMAIN, LOGGER
-from .device_sensor import PGLabDeviceSensor
+from .coordinator import PGLabSensorsCoordinator
 
 if TYPE_CHECKING:
-    from . import PGLABConfigEntry
+    from . import PGLabConfigEntry
 
 # Supported platforms.
 PLATFORMS = [
@@ -69,23 +68,28 @@ def get_device_id_from_discovery_topic(topic: str) -> str | None:
 class DiscoverDeviceInfo:
     """Keeps information of the PGLab discovered device."""
 
-    def __init__(self, pglab_device: PyPGLabDevice) -> None:
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: PGLabConfigEntry,
+        pglab_device: PyPGLabDevice,
+    ) -> None:
         """Initialize the device discovery info."""
 
         # Hash string represents the devices actual configuration,
         # it depends on the number of available relays and shutters.
         # When the hash string changes the devices entities must be rebuilt.
         self._hash = pglab_device.hash
         self._entities: list[tuple[str, str]] = []
-        self._sensors = PGLabDeviceSensor(pglab_device)
+        self.coordinator = PGLabSensorsCoordinator(hass, config_entry, pglab_device)
 
-    def add_entity(self, entity: Entity) -> None:
+    def add_entity(self, platform_domain: str, entity_unique_id: str | None) -> None:
         """Add an entity."""
 
         # PGLabEntity always have unique IDs
         if TYPE_CHECKING:
-            assert entity.unique_id is not None
-        self._entities.append((entity.platform.domain, entity.unique_id))
+            assert entity_unique_id is not None
+        self._entities.append((platform_domain, entity_unique_id))
 
     @property
     def hash(self) -> int:
@@ -97,18 +101,15 @@ def entities(self) -> list[tuple[str, str]]:
         """Return array of entities available."""
         return self._entities
 
-    @property
-    def sensors(self) -> PGLabDeviceSensor:
-        """Return the PGLab device sensor."""
-        return self._sensors
-
 
-async def createDiscoverDeviceInfo(pglab_device: PyPGLabDevice) -> DiscoverDeviceInfo:
+async def create_discover_device_info(
+    hass: HomeAssistant, config_entry: PGLabConfigEntry, pglab_device: PyPGLabDevice
+) -> DiscoverDeviceInfo:
     """Create a new DiscoverDeviceInfo instance."""
-    discovery_info = DiscoverDeviceInfo(pglab_device)
+    discovery_info = DiscoverDeviceInfo(hass, config_entry, pglab_device)
 
     # Subscribe to sensor state changes.
-    await discovery_info.sensors.subscribe_topics()
+    await discovery_info.coordinator.subscribe_topics()
     return discovery_info
 
 
@@ -184,7 +185,10 @@ def __clean_discovered_device(self, hass: HomeAssistant, device_id: str) -> None
         del self._discovered[device_id]
 
     async def start(
-        self, hass: HomeAssistant, mqtt: PyPGLabMqttClient, entry: PGLABConfigEntry
+        self,
+        hass: HomeAssistant,
+        mqtt: PyPGLabMqttClient,
+        config_entry: PGLabConfigEntry,
     ) -> None:
         """Start discovering a PGLab devices."""
 
@@ -210,7 +214,7 @@ async def discovery_message_received(msg: ReceiveMessage) -> None:
             # Create a new device.
             device_registry = dr.async_get(hass)
             device_registry.async_get_or_create(
-                config_entry_id=entry.entry_id,
+                config_entry_id=config_entry.entry_id,
                 configuration_url=f"http://{pglab_device.ip}/",
                 connections={(CONNECTION_NETWORK_MAC, pglab_device.mac)},
                 identifiers={(DOMAIN, pglab_device.id)},
@@ -241,7 +245,9 @@ async def discovery_message_received(msg: ReceiveMessage) -> None:
                 self.__clean_discovered_device(hass, pglab_device.id)
 
             # Add a new device.
-            discovery_info = await createDiscoverDeviceInfo(pglab_device)
+            discovery_info = await create_discover_device_info(
+                hass, config_entry, pglab_device
+            )
             self._discovered[pglab_device.id] = discovery_info
 
             # Create all new relay entities.
@@ -256,7 +262,7 @@ async def discovery_message_received(msg: ReceiveMessage) -> None:
                 hass,
                 CREATE_NEW_ENTITY[Platform.SENSOR],
                 pglab_device,
-                discovery_info.sensors,
+                discovery_info.coordinator,
             )
 
         topics = {
@@ -267,7 +273,7 @@ async def discovery_message_received(msg: ReceiveMessage) -> None:
         }
 
         # Forward setup all HA supported platforms.
-        await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+        await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
         self._mqtt_client = mqtt
         self._substate = async_prepare_subscribe_topics(hass, self._substate, topics)
@@ -282,22 +288,24 @@ async def register_platform(
         )
         self._disconnect_platform.append(disconnect_callback)
 
-    async def stop(self, hass: HomeAssistant, entry: PGLABConfigEntry) -> None:
+    async def stop(self, hass: HomeAssistant, config_entry: PGLabConfigEntry) -> None:
         """Stop to discovery PG LAB devices."""
-        await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+        await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)
 
         # Disconnect all registered platforms.
         for disconnect_callback in self._disconnect_platform:
             disconnect_callback()
 
         async_unsubscribe_topics(hass, self._substate)
 
-    async def add_entity(self, entity: Entity, device_id: str):
+    async def add_entity(
+        self, platform_domain: str, entity_unique_id: str | None, device_id: str
+    ):
         """Save a new PG LAB device entity."""
 
         # Be sure that the device is been discovered.
         if device_id not in self._discovered:
             raise PGLabDiscoveryError("Unknown device, device_id not discovered")
 
         discovery_info = self._discovered[device_id]
-        discovery_info.add_entity(entity)
+        discovery_info.add_entity(platform_domain, entity_unique_id)