Merging most recent changes to core repo into custom-component repo

Author: bookman-dius

custom_components/powersensor/AsyncSet.py

@@ -20,8 +20,8 @@
     RT_VHH,
     RT_ZEROCONF,
 )
-from .PowersensorDiscoveryService import PowersensorDiscoveryService
-from .PowersensorMessageDispatcher import PowersensorMessageDispatcher
+from .powersensor_discovery_service import PowersensorDiscoveryService
+from .powersensor_message_dispatcher import PowersensorMessageDispatcher
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -55,7 +55,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     manifest = integration.manifest
 
     try:
-        # Establish the zeroconf discovery service
+        # Create the zeroconf discovery service
         zeroconf_domain: str = str(manifest["zeroconf"][0])
         zeroconf_service = PowersensorDiscoveryService(hass, zeroconf_domain)
         await zeroconf_service.start()

custom_components/powersensor/__init__.py

@@ -32,6 +32,7 @@ class PowersensorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow."""
 
     VERSION = 2
+    MINOR_VERSION = 0
 
     def __init__(self) -> None:
         """Initialize the config flow."""
@@ -42,15 +43,11 @@ async def async_step_reconfigure(
         """Handle reconfigure step. The primary use case is adding missing roles to sensors."""
         entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
         if entry is None or not hasattr(entry, "runtime_data"):
-            return self.async_abort(
-                reason="Cannot reconfigure. Initial configuration incomplete or broken."
-            )
+            return self.async_abort(reason="cannot_reconfigure")
 
         dispatcher = entry.runtime_data[RT_DISPATCHER]
         if dispatcher is None:
-            return self.async_abort(
-                reason="Cannot reconfigure. Initial configuration incomplete or broken."
-            )
+            return self.async_abort(reason="cannot_reconfigure")
 
         mac2name = {mac: SENSOR_NAME_FORMAT % mac for mac in dispatcher.sensors}
 
@@ -63,7 +60,7 @@ async def async_step_reconfigure(
                     role = None
                 _LOGGER.debug("Applying %s to %s", role, mac)
                 async_dispatcher_send(self.hass, ROLE_UPDATE_SIGNAL, mac, role)
-            return self.async_abort(reason="Roles successfully applied!")
+            return self.async_abort(reason="roles_applied")
 
         sensor_roles = {}
         description_placeholders = {}
@@ -131,14 +128,16 @@ async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle zeroconf discovery."""
-        await self._common_setup()
+        if result := await self._common_setup():
+            return result
         return await self.async_step_manual_confirm()
 
     async def async_step_zeroconf(
         self, discovery_info: zeroconf.ZeroconfServiceInfo
     ) -> ConfigFlowResult:
         """Handle zeroconf discovery."""
-        await self._common_setup()
+        if result := await self._common_setup():
+            return result
         discovered_plugs_key = "discovered_plugs"
         host = discovery_info.host
         port = discovery_info.port or DEFAULT_PORT
@@ -147,7 +146,7 @@ async def async_step_zeroconf(
         if "id" in properties:
             mac = properties["id"].strip()
         else:
-            return self.async_abort(reason="Plug firmware not compatible")
+            return self.async_abort(reason="firmware_not_compatible")
 
         display_name = f"🔌 Mac({mac})"
         plug_data = {
@@ -168,9 +167,12 @@ async def async_step_zeroconf(
     async def async_step_confirm(
         self, step_id: str, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Confirm user wants to add the powersensor integration with the plugs stored in hass.data['powersensor']."""
+        "Confirm user wants to add the powersensor integration with the plugs stored in hass.data['powersensor']."
         if user_input is not None:
-            _LOGGER.debug(self.hass.data[DOMAIN]["discovered_plugs"])
+            _LOGGER.debug(
+                "Creating entry with discovered plugs: %s",
+                self.hass.data[DOMAIN]["discovered_plugs"],
+            )
             return self.async_create_entry(
                 title="Powersensor",
                 data={
@@ -183,15 +185,15 @@ async def async_step_confirm(
     async def async_step_discovery_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Confirm user wants to add the powersensor integration with the plugs discovered."""
+        "Confirm user wants to add the powersensor integration with the plugs discovered."
         return await self.async_step_confirm(
             step_id="discovery_confirm", user_input=user_input
         )
 
     async def async_step_manual_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Confirm user wants to add the powersensor integration with manual configuration (typically no plugs available)."""
+        "Confirm user wants to add the powersensor integration with manual configuration (typically no plugs available)."
         return await self.async_step_confirm(
             step_id="manual_confirm", user_input=user_input
         )

custom_components/powersensor/config_flow.py

@@ -3,7 +3,6 @@
 DOMAIN = "powersensor"
 DEFAULT_NAME = "Powersensor"
 DEFAULT_PORT = 49476
-DEFAULT_SCAN_INTERVAL = 30
 
 # Internal signals
 CREATE_PLUG_SIGNAL = f"{DOMAIN}_create_plug"
@@ -18,7 +17,7 @@
 ZEROCONF_UPDATE_PLUG_SIGNAL = f"{DOMAIN}_zeroconf_update_plug"
 
 # Formatting, would've liked to have been able to have this translatable
-SENSOR_NAME_FORMAT = "Powersensor Sensor (ID: %s) ⚡"
+SENSOR_NAME_FORMAT = "Powersensor Sensor (ID: %s)"
 
 # Config entry keys
 CFG_DEVICES = "devices"

custom_components/powersensor/const.py

@@ -8,7 +8,6 @@
   "config_flow": true,
   "dependencies": [],
   "documentation": "https://dius.github.io/homeassistant-powersensor/",
-  "homekit": {},
   "integration_type" : "hub",
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/DiUS/homeassistant-powersensor/issues",

custom_components/powersensor/manifest.json

@@ -189,6 +189,9 @@ async def stop(self):
             with suppress(asyncio.CancelledError):
                 await self._task
 
+        if self.browser is not None:
+            self.browser.cancel()
+
         if self.zc:
             # self.zc.close()
             self.zc = None

…wersensor/PowersensorDiscoveryService.py …rsensor/powersensor_discovery_service.pycustom_components/powersensor/PowersensorDiscoveryService.py renamed to custom_components/powersensor/powersensor_discovery_service.py custom_components/powersensor/PowersensorDiscoveryService.py renamed to custom_components/powersensor/powersensor_discovery_service.py

@@ -18,7 +18,6 @@
     async_dispatcher_send,
 )
 
-from .AsyncSet import AsyncSet
 from .const import (
     # Used config entry fields
     CFG_ROLES,
@@ -40,7 +39,9 @@
 
 async def _handle_exception(event: str, exc: BaseException):
     """Log errors when PlugApi throws an exception."""
-    _LOGGER.error("On event %s Plug connection reported exception: %s", event, exc)
+    _LOGGER.exception(
+        "On event %s Plug connection reported exception: %s", event, exc
+    )
 
 
 def _filter_unknown(role: str):
@@ -98,13 +99,13 @@ def __init__(
 
         self._monitor_add_plug_queue = None
         self._stop_task = False
-        self._plug_added_queue: AsyncSet = AsyncSet()
+        self._plug_added_queue: set = set()
         self._safe_to_process_plug_queue = False
 
     async def enqueue_plug_for_adding(self, network_info: dict):
         """On receiving zeroconf data this info is added to processing buffer to await creation of entity and api."""
         _LOGGER.debug("Adding to plug processing queue: %s", network_info)
-        await self._plug_added_queue.add(
+        self._plug_added_queue.add(
             (
                 network_info["mac"],
                 network_info["host"],
@@ -134,7 +135,7 @@ 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()
+                queue_snapshot = self._plug_added_queue.copy()
                 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):
@@ -162,7 +163,7 @@ async def _monitor_plug_queue(self):
                             " Skipping and flushing from queue. ",
                             mac_address,
                         )
-                        await self._plug_added_queue.remove(
+                        self._plug_added_queue.remove(
                             (mac_address, host, port, name)
                         )
 
@@ -185,9 +186,10 @@ def _get_role_info(self, message):
         """Retrieve the effective role and persisted role for this message."""
         # Filter in case older version stuck an "unknown" in there
         persisted_role = _filter_unknown(
-            self._entry.data.get(CFG_ROLES, {}).get(message['mac'], None))
+            self._entry.data.get(CFG_ROLES, {}).get(message["mac"], None)
+        )
         # The sensor *does* send "unknown", not null/None, so filter it
-        role = _filter_unknown(message.get('role', None))
+        role = _filter_unknown(message.get("role", None))
         return role, persisted_role
 
     async def stop_processing_plug_queue(self):
@@ -266,7 +268,9 @@ async def handle_relaying_for(self, event: str, message: dict):
         # We only apply a known persisted role, so we don't clobber a sensor's
         # actual knowledge.
         if persisted_role is not None and role != persisted_role:
-            _LOGGER.debug("Restoring role for %s from %s to %s", mac, role, persisted_role)
+            _LOGGER.debug(
+                "Restoring role for %s from %s to %s", mac, role, persisted_role
+            )
             async_dispatcher_send(self._hass, ROLE_UPDATE_SIGNAL, mac, persisted_role)
 
     async def handle_message(self, event: str, message: dict):
@@ -279,9 +283,9 @@ async def handle_message(self, event: str, message: dict):
         role, persisted_role = self._get_role_info(message)
 
         # Apply persisted role information if necessary
-        message['role'] = persisted_role if role is None else role
+        message["role"] = persisted_role if role is None else role
 
-        # Uknown roles from the sensor should not be allowed to overwrite
+        # Unknown roles from the sensor should not be allowed to overwrite
         # any persisted roles
         if role is not None and role != persisted_role:
             self.sensors[mac] = role
@@ -327,7 +331,7 @@ 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))
+        self._plug_added_queue.remove((mac_address, host, port, name))
 
     async def _plug_added(self, info):
         _LOGGER.debug(" Request to add plug received: %s", info)