Fix/entity renaming (#8)

* Fix device renaming on role change, plus tidy up signals by moving them to const.py

* Centralise role update message sending

* Immediately register vhh solar if starting with with_solar==True

* Change solar sensor emoji

* Trigger solar sensor detection if from reconfigure

* Clean up and simplify sensor addition and role handling

---------

Co-authored-by: Jade Mattsson <github@frozenlogic.org>

Author: bookman-dius

custom_components/powersensor/PowersensorDiscoveryService.py

@@ -6,7 +6,11 @@
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 import homeassistant.components.zeroconf
 
-from .const import DOMAIN
+from .const import (
+    ZEROCONF_ADD_PLUG_SIGNAL,
+    ZEROCONF_REMOVE_PLUG_SIGNAL,
+    ZEROCONF_UPDATE_PLUG_SIGNAL,
+)
 
 import logging
 _LOGGER = logging.getLogger(__name__)
@@ -30,7 +34,7 @@ def add_service(self, zc, type_, name):
             )
 
     async def _async_service_add(self, *args):
-        async_dispatcher_send(self._hass, f"{DOMAIN}_zeroconf_add_plug", *args)
+        async_dispatcher_send(self._hass, ZEROCONF_ADD_PLUG_SIGNAL, *args)
 
 
     async def _async_delayed_remove(self, name):
@@ -68,7 +72,7 @@ def remove_service(self, zc, type_, name):
         )
 
     async def _async_service_remove(self, *args):
-        async_dispatcher_send(self._hass, f"{DOMAIN}_zeroconf_remove_plug", *args)
+        async_dispatcher_send(self._hass, ZEROCONF_REMOVE_PLUG_SIGNAL, *args)
 
     def update_service(self, zc, type_, name):
         self.cancel_any_pending_removal(name, "request to update")
@@ -81,7 +85,7 @@ def update_service(self, zc, type_, name):
 
     async def _async_service_update(self, *args):
         # remove from pending tasks if update received
-        async_dispatcher_send(self._hass, f"{DOMAIN}_zeroconf_update_plug", *args)
+        async_dispatcher_send(self._hass, ZEROCONF_UPDATE_PLUG_SIGNAL, *args)
 
     async def _async_get_service_info(self, zc, type_, name):
         try:
@@ -160,4 +164,4 @@ async def stop(self):
             self.zc = None
 
         self.browser = None
-        self.listener = None
+        self.listener = None

custom_components/powersensor/PowersensorEntity.py

@@ -11,18 +11,18 @@
 from homeassistant.util.dt import utcnow
 from .PlugMeasurements import PlugMeasurements
 from .SensorMeasurements import SensorMeasurements
-from .const import DOMAIN, POWER_SENSOR_UPDATE_SIGNAL
+from .const import DATA_UPDATE_SIGNAL_FMT_MAC_EVENT, DOMAIN, ROLE_UPDATE_SIGNAL
 
 import logging
 _LOGGER = logging.getLogger(__name__)
 
 class PowersensorEntity(SensorEntity):
     """Powersensor Plug Class--designed to handle all measurements of the plug--perhaps less expressive"""
-    def __init__(self, hass: HomeAssistant, mac : str,
+    def __init__(self, hass: HomeAssistant, mac: str, role: str,
                  input_config: dict[Union[SensorMeasurements|PlugMeasurements], dict],
                  measurement_type: SensorMeasurements|PlugMeasurements, timeout_seconds: int = 60):
         """Initialize the sensor."""
-        self.role = None
+        self._role = role
         self._has_recently_received_update_message = False
         self._attr_native_value = 0.0
         self._hass = hass
@@ -44,7 +44,7 @@ def __init__(self, hass: HomeAssistant, mac : str,
         self._attr_entity_category = config.get('category', None)
         self._attr_state_class = config.get('state_class', None)
 
-        self._signal = f"{POWER_SENSOR_UPDATE_SIGNAL}_{self._mac}_{config['event']}"
+        self._signal = DATA_UPDATE_SIGNAL_FMT_MAC_EVENT % (mac, config['event'])
         self._message_key = config.get('message_key', None)
         self._message_callback = config.get('callback', None)
 
@@ -81,6 +81,11 @@ async def async_added_to_hass(self) -> None:
             self._signal,
             self._handle_update
         ))
+        self.async_on_remove(async_dispatcher_connect(
+            self._hass,
+            ROLE_UPDATE_SIGNAL,
+            self._handle_role_update
+        ))
 
     async def async_will_remove_from_hass(self):
         """Clean up."""
@@ -91,27 +96,12 @@ def _rename_based_on_role(self):
         return False
 
     @callback
-    def _handle_update(self, event, message):
-        """handle pushed data."""
-
-        # event is not presently used, but is passed to maintain flexibility for future development
-
-        name_updated = False
-        self._has_recently_received_update_message = True
+    def _handle_role_update(self, mac: str, role: str):
+        if self._mac != mac or self._role == role:
+            return
 
-        role = message.get('role', None)
-        if role is not None and role != self.role:
-            self.role = role
-            name_updated = self._rename_based_on_role()
-            async_dispatcher_send(self._hass, f"{DOMAIN}_update_role", self._mac, role)
-
-
-        if self._message_key in message.keys():
-            if self._message_callback:
-                self._attr_native_value = self._message_callback( message[self._message_key])
-            else:
-                self._attr_native_value = message[self._message_key]
-        self._schedule_unavailable()
+        self._role = role
+        name_updated = self._rename_based_on_role()
 
         if name_updated:
             device_registry = dr.async_get(self._hass)
@@ -131,5 +121,22 @@ def _handle_update(self, event, message):
                 self.entity_id,
                 name = self._attr_name
             )
-        self.async_write_ha_state()
 
+            self.async_write_ha_state()
+
+    @callback
+    def _handle_update(self, event, message):
+        """handle pushed data."""
+
+        # event is not presently used, but is passed to maintain flexibility for future development
+
+        self._has_recently_received_update_message = True
+
+        if self._message_key in message.keys():
+            if self._message_callback:
+                self._attr_native_value = self._message_callback( message[self._message_key])
+            else:
+                self._attr_native_value = message[self._message_key]
+        self._schedule_unavailable()
+
+        self.async_write_ha_state()

custom_components/powersensor/PowersensorMessageDispatcher.py

@@ -9,7 +9,17 @@
 from powersensor_local import PlugApi, VirtualHousehold
 
 from custom_components.powersensor.AsyncSet import AsyncSet
-from custom_components.powersensor.const import POWER_SENSOR_UPDATE_SIGNAL, DOMAIN
+from custom_components.powersensor.const import (
+    CREATE_PLUG_SIGNAL,
+    CREATE_SENSOR_SIGNAL,
+    DATA_UPDATE_SIGNAL_FMT_MAC_EVENT,
+    PLUG_ADDED_TO_HA_SIGNAL,
+    ROLE_UPDATE_SIGNAL,
+    SENSOR_ADDED_TO_HA_SIGNAL,
+    ZEROCONF_ADD_PLUG_SIGNAL,
+    ZEROCONF_REMOVE_PLUG_SIGNAL,
+    ZEROCONF_UPDATE_PLUG_SIGNAL,
+)
 
 _LOGGER = logging.getLogger(__name__)
 class PowersensorMessageDispatcher:
@@ -25,28 +35,23 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry, vhh: VirtualHousehol
         self._pending_removals = {}
         self._debounce_seconds = debounce_timeout
         self.has_solar = False
-        self._virtual_household_has_been_setup = False
-        self._last_request_to_notify_about_solar = datetime.datetime(1970,1,1,0,0,0)
         self._solar_request_limit = datetime.timedelta(seconds = 10)
         self._unsubscribe_from_signals = [
             async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_sensor_added_to_homeassistant",
-                                     self._acknowledge_sensor_added_to_homeassistant),
-            async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_zeroconf_add_plug",
+                                     ZEROCONF_ADD_PLUG_SIGNAL,
                                      self._plug_added),
             async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_zeroconf_update_plug",
+                                     ZEROCONF_UPDATE_PLUG_SIGNAL,
                                      self._plug_updated),
             async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_zeroconf_remove_plug",
+                                     ZEROCONF_REMOVE_PLUG_SIGNAL,
                                      self._schedule_plug_removal),
             async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_plug_added_to_homeassistant",
+                                     PLUG_ADDED_TO_HA_SIGNAL,
                                      self._acknowledge_plug_added_to_homeassistant),
             async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_solar_added_to_virtual_household",
-                                     self._acknowledge_solar_added_to_virtual_household),
+                                     SENSOR_ADDED_TO_HA_SIGNAL,
+                                     self._acknowledge_sensor_added_to_homeassistant),
         ]
 
         self._monitor_add_plug_queue = None
@@ -78,7 +83,7 @@ async def _monitor_plug_queue(self):
                 for mac_address, host, port, name in queue_snapshot:
                     #@todo: maybe better to query the entity registry?
                     if not self._plug_has_been_seen(mac_address, name):
-                        async_dispatcher_send(self._hass, f"{DOMAIN}_create_plug",
+                        async_dispatcher_send(self._hass, CREATE_PLUG_SIGNAL,
                                               mac_address, host, port, name)
                     elif mac_address in self._known_plugs and not mac_address in self.plugs:
                         _LOGGER.info(f"Plug with mac {mac_address} is known, but API is missing."
@@ -135,62 +140,72 @@ def _create_api(self, mac_address, ip, port, name):
         self._known_plugs.add(mac_address)
         self._known_plug_names[name] = mac_address
         known_evs = [
-            'exception',
+            #'exception',
             'average_flow',
             'average_power',
             'average_power_components',
             'battery_level',
-            'now_relaying_for',
             'radio_signal_quality',
             'summation_energy',
             'summation_volume',
-            'uncalibrated_instant_reading',
+            #'uncalibrated_instant_reading',
         ]
 
         for ev in known_evs:
-            api.subscribe(ev, lambda event, message: self.handle_message( event, message))
+            api.subscribe(ev, self.handle_message)
+        api.subscribe('now_relaying_for', self.handle_relaying_for)
         api.connect()
 
-    def add_api(self, network_info):
-        _LOGGER.debug("Manually adding API, this could cause API's and entities to get out of sync")
-        self._create_api(mac_address=network_info['mac'], ip=network_info['host'],
-                         port=network_info['port'], name=network_info['name'])
-
     def cancel_any_pending_removal(self, mac, source):
         task = self._pending_removals.pop(mac, None)
         if task:
             task.cancel()
             _LOGGER.debug(f"Cancelled pending removal for {mac} by {source}.")
 
+    async def handle_relaying_for(self, event: str, message: dict):
+        """Handle a potentially new sensor being reported."""
+        mac = message.get('mac', None)
+        device_type = message.get('device_type', None)
+        if mac is None or device_type != "sensor":
+            _LOGGER.warning(f"Ignoring relayed device with MAC \"{mac}\" and type {device_type}")
+            return
+
+        persisted_role = self._entry.data.get('roles', {}).get(mac, None)
+        role = message.get('role', None)
+        _LOGGER.debug(f"Relayed sensor {mac} with role {role} found")
+
+        if mac not in self.sensors:
+            _LOGGER.debug(f"Reporting new sensor {mac} with role {role}")
+            self.on_start_sensor_queue[mac] = role
+            async_dispatcher_send(self._hass, CREATE_SENSOR_SIGNAL, mac, role)
+        if role != persisted_role:
+            _LOGGER.debug(f"Restoring role for {mac} from {role} to {persisted_role}")
+            async_dispatcher_send(self._hass, ROLE_UPDATE_SIGNAL, mac, persisted_role)
+
     async def handle_message(self, event: str, message: dict):
         mac = message['mac']
-        role = message.get('role', None)
-        if role is None:
-            role = self._entry.data.get('roles', {}).get(mac, None)
-        self.cancel_any_pending_removal(mac, "new message received from plug")
+        persisted_role = self._entry.data.get('roles', {}).get(mac, None)
+        role = message.get('role', persisted_role)
+        message['role'] = role
 
-        if mac not in self.plugs.keys():
-            if mac not in self.sensors:
-                if role is not None:
-                    self.on_start_sensor_queue[mac] = role
-                async_dispatcher_send(self._hass, f"{DOMAIN}_create_sensor", mac, role)
+        if role != persisted_role:
+            async_dispatcher_send(self._hass, ROLE_UPDATE_SIGNAL, mac, role)
+
+        self.cancel_any_pending_removal(mac, "new message received from plug")
 
         # Feed the household calculations
         if event == 'average_power':
             await self._vhh.process_average_power_event(message)
         elif event == 'summation_energy':
             await self._vhh.process_summation_event(message)
-        if role == 'solar':
-            self.has_solar = True
-            if not self._virtual_household_has_been_setup:
-                new_time = datetime.datetime.now()
-                if self._last_request_to_notify_about_solar + self._solar_request_limit <new_time:
-                    self._last_request_to_notify_about_solar = new_time
-                    _LOGGER.debug("Notifying integration that solar is present.")
-                    async_dispatcher_send(self._hass, f"{DOMAIN}_solar_sensor_detected")
-        async_dispatcher_send(self._hass, f"{POWER_SENSOR_UPDATE_SIGNAL}_{mac}_{event}", event, message)
-        if role is not None:
-            async_dispatcher_send(self._hass, f"{POWER_SENSOR_UPDATE_SIGNAL}_{mac}_role", 'role', { 'role': role })
+
+        async_dispatcher_send(self._hass,
+              DATA_UPDATE_SIGNAL_FMT_MAC_EVENT % (mac, event), event, message)
+
+        # Synthesise a role type message for the role diagnostic entity
+        async_dispatcher_send(
+            self._hass, DATA_UPDATE_SIGNAL_FMT_MAC_EVENT % (mac, role),
+            'role', { 'role': role })
 
     async def disconnect(self):
         for _ in range(len(self.plugs)):
@@ -208,10 +223,6 @@ def _acknowledge_sensor_added_to_homeassistant(self,mac, role):
         self.sensors[mac] = role
 
     @callback
-    def _acknowledge_solar_added_to_virtual_household(self, success):
-        _LOGGER.debug("Solar has been added to virtual household.")
-        self._virtual_household_has_been_setup = success
-
     async def _acknowledge_plug_added_to_homeassistant(self, mac_address, host, port, name):
         self._create_api(mac_address, host, port, name)
         await self._plug_added_queue.remove((mac_address, host, port, name))

custom_components/powersensor/PowersensorPlugEntity.py

@@ -79,9 +79,9 @@
 
 class PowersensorPlugEntity(PowersensorEntity):
     """Powersensor Plug Class--designed to handle all measurements of the plug--perhaps less expressive"""
-    def __init__(self, hass: HomeAssistant, mac_address: str, measurement_type: PlugMeasurements):
+    def __init__(self, hass: HomeAssistant, mac_address: str, role: str, measurement_type: PlugMeasurements):
         """Initialize the sensor."""
-        super().__init__(hass, mac_address, _config, measurement_type)
+        super().__init__(hass, mac_address, role, _config, measurement_type)
         self._model = f"PowersensorPlug"
         self.measurement_type = measurement_type
         config = _config[measurement_type]

custom_components/powersensor/PowersensorSensorEntity.py

@@ -51,44 +51,43 @@
 
 class PowersensorSensorEntity(PowersensorEntity):
     """Powersensor Plug Class--designed to handle all measurements of the plug--perhaps less expressive"""
-    def __init__(self, hass: HomeAssistant, mac : str,
+    def __init__(self, hass: HomeAssistant, mac: str, role: str,
                  measurement_type: SensorMeasurements):
         """Initialize the sensor."""
-        super().__init__(hass, mac, _config, measurement_type)
+        super().__init__(hass, mac, role, _config, measurement_type)
         self._model = f"PowersensorSensor"
         self.measurement_type = measurement_type
         config = _config[measurement_type]
         self._measurement_name = config['name']
         self._device_name = self._default_device_name()
         self._attr_name = f"{self._device_name} {self._measurement_name}"
-        self._rename_based_on_role()
 
     @property
     def device_info(self) -> DeviceInfo:
         return {
             'identifiers': {(DOMAIN, self._mac)},
             'manufacturer': "Powersensor",
             'model': self._model,
-            'name': self._device_name ,
+            'name': self._device_name,
         }
 
     def _ensure_matching_prefix(self):
         if not self._attr_name.startswith(self._device_name):
             self._attr_name = f"{self._device_name} {self._measurement_name }"
 
-    def _rename_based_on_role(self):
-        if self._device_name == self._default_device_name():
-            if self.role =='house-net' or self.role == "water" or self.role == "solar":
-                role2name = {
-                  "house-net": "Powersensor Mains Sensor ⚡",
-                  "solar": "Powersensor Solar Sensor ⚡",
-                  "water": "Powersensor Water Sensor 💧",
-                }
-                self._device_name = role2name[self.role]
-                self._ensure_matching_prefix()
-                return True
-        return False
-
-    def _default_device_name(self):
-        return SENSOR_NAME_FORMAT % self._mac
+    def _rename_based_on_role(self) -> bool:
+        expected_name = self._default_device_name()
+        if self._device_name != expected_name:
+            self._device_name = expected_name
+            self._ensure_matching_prefix()
+            return True
+        else:
+            return False
 
+    def _default_device_name(self) -> str:
+        role2name = {
+          "house-net": "Powersensor Mains Sensor ⚡",
+          "solar": "Powersensor Solar Sensor ☀️",
+          "water": "Powersensor Water Sensor 💧",
+        }
+        return role2name[self._role] if self._role in [ "house-net", "water", "solar" ] else SENSOR_NAME_FORMAT % self._mac