Adding tracking of zeroconf names, various errors patched.

Author: bookman-dius

custom_components/powersensor/PowersensorEntity.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Callable
+from typing import Callable, Union
 
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.core import HomeAssistant, callback
@@ -19,7 +19,7 @@
 class PowersensorEntity(SensorEntity):
     """Powersensor Plug Class--designed to handle all measurements of the plug--perhaps less expressive"""
     def __init__(self, hass: HomeAssistant, mac : str,
-                 get_config_by_measurement_type: Callable[[SensorMeasurements|PlugMeasurements], dict],
+                 input_config: dict[Union[SensorMeasurements|PlugMeasurements], dict],
                  measurement_type: SensorMeasurements|PlugMeasurements, timeout_seconds: int = 60):
         """Initialize the sensor."""
         self.role = None
@@ -28,13 +28,13 @@ def __init__(self, hass: HomeAssistant, mac : str,
         self._hass = hass
         self._mac = mac
         self._model = f"PowersensorDevice"
-        self._device_name = f'PowersensorDevice MAC address: ({self._mac})'
+        self._device_name = f'Powersensor Device (MAC address: {self._mac})'
         self._measurement_name= None
         self._remove_unavailability_tracker = None
         self._timeout = timedelta(seconds=timeout_seconds)  # Adjust as needed
 
         self.measurement_type = measurement_type
-        config = get_config_by_measurement_type(measurement_type)
+        config = input_config[measurement_type]
         self._attr_unique_id = f"powersensor_{mac}_{measurement_type}"
         self._attr_device_class = config["device_class"]
         self._attr_native_unit_of_measurement = config["unit"]
@@ -91,43 +91,41 @@ def _rename_based_on_role(self):
     @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
-        if event =="remove_sensor":
-            self.async_remove()
-        elif event =="mark_unavailable":
-            self._has_recently_received_update_message = False
-        else:
-            self._has_recently_received_update_message = True
-            if not self.role:
-                if 'role' in message.keys():
-                    self.role = message['role']
-                    name_updated = self._rename_based_on_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()
-
-            if name_updated:
-                device_registry = dr.async_get(self.hass)
-                device = device_registry.async_get_device(
-                    identifiers={(DOMAIN, self._mac)}
+        self._has_recently_received_update_message = True
+        if not self.role:
+            if 'role' in message.keys():
+                self.role = message['role']
+                name_updated = self._rename_based_on_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()
+
+        if name_updated:
+            device_registry = dr.async_get(self.hass)
+            device = device_registry.async_get_device(
+                identifiers={(DOMAIN, self._mac)}
+            )
+
+            if device and device.name != self._device_name:
+                # Update the device name
+                device_registry.async_update_device(
+                    device.id,
+                    name=self._device_name
                 )
 
-                if device and device.name != self._device_name:
-                    # Update the device name
-                    device_registry.async_update_device(
-                        device.id,
-                        name=self._device_name
-                    )
-
-                entity_registry = er.async_get(self.hass)
-                entity_registry.async_update_entity(
-                    self.entity_id,
-                    name = self._attr_name
-                )
-            self.async_write_ha_state()
+            entity_registry = er.async_get(self.hass)
+            entity_registry.async_update_entity(
+                self.entity_id,
+                name = self._attr_name
+            )
+        self.async_write_ha_state()
 

custom_components/powersensor/PowersensorMessageDispatacher.py

@@ -16,6 +16,7 @@ def __init__(self, hass: HomeAssistant, vhh: VirtualHousehold):
         self._vhh = vhh
         self.plugs = dict()
         self._known_plugs = set()
+        self._known_plug_names = dict()
         self.sensors = dict()
         self.on_start_sensor_queue = dict()
         self._unsubscribe_from_signals = [
@@ -43,7 +44,8 @@ def __init__(self, hass: HomeAssistant, vhh: VirtualHousehold):
 
     async def enqueue_plug_for_adding(self, network_info: dict):
         _LOGGER.debug(f"Adding to plug processing queue: {network_info}")
-        await self._plug_added_queue.add((network_info['mac'], network_info['host'], network_info['port']))
+        await self._plug_added_queue.add((network_info['mac'], network_info['host'],
+                                          network_info['port'], network_info['name']))
 
     async def process_plug_queue(self):
         """Start the background task if not already running."""
@@ -53,22 +55,22 @@ async def process_plug_queue(self):
             self._monitor_add_plug_queue = self._hass.async_create_background_task(self._monitor_plug_queue(), name="plug_queue_monitor")
             _LOGGER.debug("Background task started")
 
-    def _plug_has_been_seen(self, mac_address)->bool:
-        return mac_address in self.plugs or mac_address in self._known_plugs
+    def _plug_has_been_seen(self, mac_address, name)->bool:
+        return mac_address in self.plugs or mac_address in self._known_plugs or name in self._known_plug_names
 
     async def _monitor_plug_queue(self):
         """The actual background task loop."""
         try:
             while not self._stop_task and self._plug_added_queue:
                 queue_snapshot = await self._plug_added_queue.copy()
-                for mac_address, host, port in queue_snapshot:
-                    if not self._plug_has_been_seen(mac_address):
+                for mac_address, host, port, name in queue_snapshot:
+                    if not self._plug_has_been_seen(mac_address, name):
                         async_dispatcher_send(self._hass, f"{DOMAIN}_create_plug",
-                                              mac_address, host, port)
+                                              mac_address, host, port, name)
                     else:
                         _LOGGER.debug(f"Plug: {mac_address} has already been created as an entity in Home Assistant."
                                       f" Skipping and flushing from queue.")
-                        await self._plug_added_queue.remove((mac_address, host, port))
+                        await self._plug_added_queue.remove((mac_address, host, port, name))
 
 
                 await asyncio.sleep(5)
@@ -94,11 +96,12 @@ async def stop_processing_plug_queue(self):
             _LOGGER.debug("Background task stopped")
             self._monitor_add_plug_queue = None
 
-    def _create_api(self, mac_address, ip, port):
-        _LOGGER.info(f"Adding API for mac={mac_address}, ip={ip}, port={port}")
+    def _create_api(self, mac_address, ip, port, name):
+        _LOGGER.info(f"Creating API for mac={mac_address}, ip={ip}, port={port}")
         api = PlugApi(mac=mac_address, ip=ip, port=port)
         self.plugs[mac_address] = api
         self._known_plugs.add(mac_address)
+        self._known_plug_names[name] = mac_address
         known_evs = [
             'exception',
             'average_flow',
@@ -117,7 +120,9 @@ def _create_api(self, mac_address, ip, port):
         api.connect()
 
     def add_api(self, network_info):
-        self._create_api(mac_address=network_info['mac'], ip=network_info['host'], port=network_info['port'])
+        _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'])
 
 
     async def handle_message(self, event: str, message: dict):
@@ -152,49 +157,59 @@ async def disconnect(self):
     def _acknowledge_sensor_added_to_homeassistant(self,mac, role):
         self.sensors[mac] = role
 
-    @callback
-    async def _acknowledge_plug_added_to_homeassistant(self, mac_address, host, port):
-        self._create_api(mac_address, host, port)
-        await self._plug_added_queue.remove((mac_address, host, port))
+    async def _acknowledge_plug_added_to_homeassistant(self, mac_address, host, port, name):
+        _LOGGER.info(f"Adding new API for mac={mac_address}, ip={host}, port={port}")
+        self._create_api(mac_address, host, port, name)
+        await self._plug_added_queue.remove((mac_address, host, port, name))
 
-    @callback
     async def _plug_added(self, info):
         _LOGGER.debug(f" Request to add plug received: {info}")
         network_info = dict()
         network_info['mac'] = info['properties'][b'id'].decode('utf-8')
         network_info['host'] = info['addresses'][0]
         network_info['port'] = info['port']
+        network_info['name'] = info['name']
 
         if self._safe_to_process_plug_queue:
             await self.enqueue_plug_for_adding(network_info)
             await self.process_plug_queue()
         else:
             await self.enqueue_plug_for_adding(network_info)
 
-    @callback
     async def _plug_updated(self, info):
         _LOGGER.debug(f" Request to update plug received: {info}")
         mac = info['properties'][b'id'].decode('utf-8')
         host = info['addresses'][0]
         port = info['port']
+        name = info['name']
+
         if mac in self.plugs:
-            self.plugs[mac].disconnect()
+            current_api: PlugApi = self.plugs[mac]
+            if current_api._listener._ip == host and current_api._listener._port == port:
+                _LOGGER.info(f"Request to update plug with mac {mac} does not alter ip from existing API."
+                             f"IP still {host} and port is {port}. Skipping update...")
+                return
+            await current_api.disconnect()
 
         if mac in self._known_plugs:
-            self._create_api(mac, host, port)
+            self._create_api(mac, host, port, name)
         else:
             network_info = dict()
             network_info['mac'] = mac
             network_info['host'] = host
             network_info['port'] = port
+            network_info['name'] = name
             await self.enqueue_plug_for_adding(network_info)
             await self.process_plug_queue()
 
-    @callback
-    def _plug_remove(self,name, info):
+    async def _plug_remove(self,name, info):
         _LOGGER.debug(f" Request to delete plug received: {info}")
-        mac = info['properties'][b'id'].decode('utf-8')
-        if mac in self.plugs:
-            self.plugs[mac].disconnect()
+        if name in self._known_plug_names:
+            mac = self._known_plug_names[name]
+            if mac in self.plugs:
+                await self.plugs[mac].disconnect()
 
-        del self.plugs[mac]
+            del self.plugs[mac]
+        else:
+            _LOGGER.warning(f"Received request to delete api for gateway with name [{name}], but this name"
+                            f"is not associated with an existing PlugAPI. Ignoring...")

custom_components/powersensor/PowersensorPlugEntity.py

@@ -12,78 +12,84 @@
 _LOGGER = logging.getLogger(__name__)
 
 
-def get_config(measurement_type: PlugMeasurements)->dict:
-    _config = {
-        PlugMeasurements.WATTS: {
-            "name": "Power",
-            "device_class": SensorDeviceClass.POWER,
-            "unit": UnitOfPower.WATT,
-            "precision": 1,
-            'event': 'average_power',
-            'message_key': 'watts'
-        },
-        PlugMeasurements.VOLTAGE: {
-            "name": "Volts",
-            "device_class": SensorDeviceClass.VOLTAGE,
-            "unit": UnitOfElectricPotential.VOLT,
-            "precision": 2,
-            'event': 'average_power_components',
-            'message_key': 'volts'
-        },
-        PlugMeasurements.APPARENT_CURRENT: {
-            "name": "Apparent Current",
-            "device_class": SensorDeviceClass.CURRENT,
-            "unit": UnitOfElectricCurrent.AMPERE,
-            "precision": 2,
-            'event': 'average_power_components',
-            'message_key': 'apparent_current'
-        },
-        PlugMeasurements.ACTIVE_CURRENT: {
-            "name": "Current", #"Active Current"
-            "device_class": SensorDeviceClass.CURRENT,
-            "unit": UnitOfElectricCurrent.AMPERE,
-            "precision": 2,
-            'event': 'average_power_components',
-            'message_key': 'active_current'
-        },
-        PlugMeasurements.REACTIVE_CURRENT: {
-            "name": "Reactive Current",
-            "device_class": SensorDeviceClass.CURRENT,
-            "unit": UnitOfElectricCurrent.AMPERE,
-            "precision": 2,
-            'event': 'average_power_components',
-            'message_key': 'reactive_current'
-        },
-        PlugMeasurements.SUMMATION_ENERGY: {
-            "name": "Total Energy",
-            "device_class": SensorDeviceClass.ENERGY,
-            "unit": UnitOfEnergy.KILO_WATT_HOUR,
-            "precision": 2,
-            "state_class": SensorStateClass.TOTAL,
-            'event': 'summation_energy',
-            'message_key': 'summation_joules',
-            'callback' : lambda v : v/3600000.0
-        },
-    }
 
-    return _config[measurement_type]
+_config = {
+    PlugMeasurements.WATTS: {
+        "name": "Power",
+        "device_class": SensorDeviceClass.POWER,
+        "unit": UnitOfPower.WATT,
+        "precision": 1,
+        'event': 'average_power',
+        'message_key': 'watts'
+    },
+    PlugMeasurements.VOLTAGE: {
+        "name": "Volts",
+        "device_class": SensorDeviceClass.VOLTAGE,
+        "unit": UnitOfElectricPotential.VOLT,
+        "precision": 2,
+        'event': 'average_power_components',
+        'message_key': 'volts'
+    },
+    PlugMeasurements.APPARENT_CURRENT: {
+        "name": "Apparent Current",
+        "device_class": SensorDeviceClass.CURRENT,
+        "unit": UnitOfElectricCurrent.AMPERE,
+        "precision": 2,
+        'event': 'average_power_components',
+        'message_key': 'apparent_current'
+    },
+    PlugMeasurements.ACTIVE_CURRENT: {
+        "name": "Current", #"Active Current"
+        "device_class": SensorDeviceClass.CURRENT,
+        "unit": UnitOfElectricCurrent.AMPERE,
+        "precision": 2,
+        'event': 'average_power_components',
+        'message_key': 'active_current'
+    },
+    PlugMeasurements.REACTIVE_CURRENT: {
+        "name": "Reactive Current",
+        "device_class": SensorDeviceClass.CURRENT,
+        "unit": UnitOfElectricCurrent.AMPERE,
+        "precision": 2,
+        'event': 'average_power_components',
+        'message_key': 'reactive_current'
+    },
+    PlugMeasurements.SUMMATION_ENERGY: {
+        "name": "Total Energy",
+        "device_class": SensorDeviceClass.ENERGY,
+        "unit": UnitOfEnergy.KILO_WATT_HOUR,
+        "precision": 2,
+        "state_class": SensorStateClass.TOTAL,
+        'event': 'summation_energy',
+        'message_key': 'summation_joules',
+        'callback' : lambda v : v/3600000.0
+    },
+}
+
+
 
 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):
         """Initialize the sensor."""
-        super().__init__(hass, mac_address, get_config, measurement_type)
+        super().__init__(hass, mac_address, _config, measurement_type)
         self._model = f"PowersensorPlug"
         self.measurement_type = measurement_type
-        config = get_config(measurement_type)
-        self._attr_name = f"🔌 MAC address: ({self._mac}) {config['name']}"
+        config = _config[measurement_type]
+        self._device_name = self._default_device_name()
+        self._attr_name = f"{self._device_name } {config['name']}"
 
     @property
     def device_info(self) -> DeviceInfo:
         return {
             'identifiers': {(DOMAIN, self._mac)},
             'manufacturer': "Powersensor",
             'model': self._model,
-            'name': f'🔌 MAC address: ({self._mac})',
+            'name': self._device_name,
             # "via_device": # if we use this, can it be updated dynamically?
         }
+
+    def _default_device_name(self) -> str:
+        # f'🔌 MAC address: ({self._mac})'
+        return f"Powersensor Plug (MAC Address: {self._mac})"
+