Fix device renaming on role change

Plus tidy up signals by moving them to const.py

Author: jmattsson

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,27 @@ 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
+
+        name_updated = False
+        self._has_recently_received_update_message = True
+
+        role = message.get('role', None)
+        if role is not None and role != self._role:
+            async_dispatcher_send(self._hass, ROLE_UPDATE_SIGNAL, 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.async_write_ha_state()

custom_components/powersensor/PowersensorMessageDispatcher.py

@@ -9,7 +9,18 @@
 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,
+    SENSOR_ADDED_TO_HA_SIGNAL,
+    SOLAR_ADDED_TO_VHH_SIGNAL,
+    SOLAR_SENSOR_DETECTED_SIGNAL,
+    ZEROCONF_ADD_PLUG_SIGNAL,
+    ZEROCONF_REMOVE_PLUG_SIGNAL,
+    ZEROCONF_UPDATE_PLUG_SIGNAL,
+)
 
 _LOGGER = logging.getLogger(__name__)
 class PowersensorMessageDispatcher:
@@ -30,22 +41,22 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry, vhh: VirtualHousehol
         self._solar_request_limit = datetime.timedelta(seconds = 10)
         self._unsubscribe_from_signals = [
             async_dispatcher_connect(self._hass,
-                                     f"{DOMAIN}_sensor_added_to_homeassistant",
+                                     SENSOR_ADDED_TO_HA_SIGNAL,
                                      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",
+                                     SOLAR_ADDED_TO_VHH_SIGNAL,
                                      self._acknowledge_solar_added_to_virtual_household),
         ]
 
@@ -78,7 +89,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."
@@ -173,7 +184,7 @@ async def handle_message(self, event: str, message: dict):
             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)
+                async_dispatcher_send(self._hass, CREATE_SENSOR_SIGNAL, mac, role)
 
         # Feed the household calculations
         if event == 'average_power':
@@ -187,10 +198,13 @@ async def handle_message(self, event: str, message: dict):
                 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)
+                    async_dispatcher_send(self._hass, SOLAR_SENSOR_DETECTED_SIGNAL)
+        async_dispatcher_send(self._hass,
+              DATA_UPDATE_SIGNAL_FMT_MAC_EVENT % (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, role),
+                'role', { 'role': role })
 
     async def disconnect(self):
         for _ in range(len(self.plugs)):

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

custom_components/powersensor/config_flow.py

@@ -9,7 +9,7 @@
 from homeassistant.helpers.service_info import zeroconf
 from homeassistant.helpers.selector import selector
 
-from .const import DEFAULT_PORT, DOMAIN, SENSOR_NAME_FORMAT
+from .const import DEFAULT_PORT, DOMAIN, ROLE_UPDATE_SIGNAL, SENSOR_NAME_FORMAT
 
 def _extract_device_name(discovery_info) -> str:
     """Extract a user-friendly device name from zeroconf info."""
@@ -65,7 +65,7 @@ async def async_step_reconfigure(self, user_input: dict | None = None)->FlowResu
                 if role == unknown:
                     role = None
                 _LOGGER.debug(f"Applying {role} to {mac}")
-                async_dispatcher_send(self.hass, f"{DOMAIN}_update_role", mac, role)
+                async_dispatcher_send(self.hass, ROLE_UPDATE_SIGNAL, mac, role)
             return self.async_abort(reason="Roles successfully applied!")
 
         sensor_roles = {}

custom_components/powersensor/const.py

@@ -4,6 +4,18 @@
 DEFAULT_NAME = "Powersensor"
 DEFAULT_PORT = 49476
 DEFAULT_SCAN_INTERVAL = 30
-POWER_SENSOR_UPDATE_SIGNAL = f"{DOMAIN}_sensor"
+
+CREATE_PLUG_SIGNAL = f"{DOMAIN}_create_plug"
+CREATE_SENSOR_SIGNAL = f"{DOMAIN}_create_sensor"
+DATA_UPDATE_SIGNAL_FMT_MAC_EVENT = f"{DOMAIN}_data_update_%s_%s"
+ROLE_UPDATE_SIGNAL = f"{DOMAIN}_update_role"
+PLUG_ADDED_TO_HA_SIGNAL = f"{DOMAIN}_plug_added_to_homeassistant"
+SENSOR_ADDED_TO_HA_SIGNAL = f"{DOMAIN}_sensor_added_to_homeassistant"
+SOLAR_SENSOR_DETECTED_SIGNAL = f"{DOMAIN}_solar_sensor_detected"
+SOLAR_ADDED_TO_VHH_SIGNAL = f"{DOMAIN}_solar_added_to_virtual_household"
+ZEROCONF_ADD_PLUG_SIGNAL = f"{DOMAIN}_zeroconf_add_plug"
+ZEROCONF_REMOVE_PLUG_SIGNAL = f"{DOMAIN}_zeroconf_remove_plug"
+ZEROCONF_UPDATE_PLUG_SIGNAL = f"{DOMAIN}_zeroconf_update_plug"
+
 
 SENSOR_NAME_FORMAT = "Powersensor Sensor (ID: %s) ⚡"