Improve device-delete related functions

CHANGELOG.md

@@ -2,8 +2,10 @@
 
 ## Versions from 0.40 and up
 
-## Ongoing
+## v0.48.0
 
+- Add a delete-button per device, enables the user to manually delete a removed Plugwise device
+- Add automatic deletion of removed Plugwise devices after a HA restart
 - Replace outdated test-fixture, update related test-case.
 
 ## v0.47.4

custom_components/plugwise/__init__.py

@@ -21,6 +21,7 @@
     UNDO_UPDATE_LISTENER,
 )
 from .coordinator import PlugwiseDataUpdateCoordinator
+from .util import cleanup_device_registry
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -35,7 +36,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     LOGGER.debug("DUC cooldown interval: %s", cooldown)
 
     coordinator = PlugwiseDataUpdateCoordinator(
-        hass, entry, cooldown
+        hass, cooldown
     )  # pw-beta - cooldown, update_interval as extra
     await coordinator.async_config_entry_first_refresh()
     # Migrate a changed sensor unique_id
@@ -48,6 +49,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         UNDO_UPDATE_LISTENER: undo_listener,  # pw-beta
     }
 
+    # Clean-up removed devices
+    cleanup_device_registry(hass, coordinator.data, entry)
+
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
@@ -85,20 +89,28 @@ async def delete_notification(
 
     return True
 
-
 async def _update_listener(
     hass: HomeAssistant, entry: ConfigEntry
 ) -> None:  # pragma: no cover  # pw-beta
     """Handle options update."""
     await hass.config_entries.async_reload(entry.entry_id)
 
-
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
         hass.data[DOMAIN].pop(entry.entry_id)
     return unload_ok
 
+async def async_remove_config_entry_device(
+    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: dr.DeviceEntry
+) -> bool:
+    """Remove no longer present Plugwise device from config/device_registry."""
+    coordinator: PlugwiseDataUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR]
+    return not any(
+        identifier
+        for identifier in device_entry.identifiers
+        if identifier[0] == DOMAIN and (identifier[1] in coordinator.data.devices)
+    )
 
 @callback
 def async_migrate_entity_entry(entry: er.RegistryEntry) -> dict[str, Any] | None:
@@ -118,7 +130,6 @@ def async_migrate_entity_entry(entry: er.RegistryEntry) -> dict[str, Any] | None
     # No migration needed
     return None
 
-
 def migrate_sensor_entities(
     hass: HomeAssistant,
     coordinator: PlugwiseDataUpdateCoordinator,

custom_components/plugwise/coordinator.py

@@ -20,65 +20,23 @@
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryError
-from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DEFAULT_PORT, DEFAULT_SCAN_INTERVAL, DEFAULT_USERNAME, DOMAIN, LOGGER
 
 
-def remove_stale_devices(
-    data: PlugwiseData,
-    device_registry: dr.DeviceRegistry,
-    via_id: str,
-) -> None:
-    """Process the Plugwise devices present in the device_registry connected to a specific Gateway."""
-    device_list = list(data.devices.keys())
-    for dev_id, device_entry in list(device_registry.devices.items()):
-        if device_entry.via_device_id == via_id:
-            for item in device_entry.identifiers:
-                if item[0] == DOMAIN and item[1] in device_list:
-                    continue
-
-                device_registry.async_remove_device(dev_id)
-                LOGGER.debug(
-                    "Removed device %s %s %s from device_registry",
-                    DOMAIN,
-                    device_entry.model,
-                    dev_id,
-                )
-
-
-def cleanup_device_registry(
-    hass: HomeAssistant,
-    data: PlugwiseData,
-) -> None:
-    """Remove deleted devices from device-registry."""
-    device_registry = dr.async_get(hass)
-    via_id_list: list[list[str]] = []
-    # Collect the required data of the Plugwise Gateway's
-    for device_entry in list(device_registry.devices.values()):
-        if device_entry.manufacturer == "Plugwise" and device_entry.model == "Gateway":
-            for item in device_entry.identifiers:
-                via_id_list.append([item[1], device_entry.id])
-
-    for via_id in via_id_list:
-        if via_id[0] != data.gateway["gateway_id"]:
-            continue  # pragma: no cover
-
-        remove_stale_devices(data, device_registry, via_id[1])
-
-
 class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[PlugwiseData]):
     """Class to manage fetching Plugwise data from single endpoint."""
 
     _connected: bool = False
 
+    config_entry: ConfigEntry
+
     def __init__(
         self,
         hass: HomeAssistant,
-        entry: ConfigEntry,
         cooldown: float,
         update_interval: timedelta = timedelta(seconds=60),
     ) -> None:  # pw-beta cooldown
@@ -100,17 +58,14 @@ def __init__(
         )
 
         self.api = Smile(
-            host=entry.data[CONF_HOST],
-            username=entry.data.get(CONF_USERNAME, DEFAULT_USERNAME),
-            password=entry.data[CONF_PASSWORD],
-            port=entry.data.get(CONF_PORT, DEFAULT_PORT),
+            host=self.config_entry.data[CONF_HOST],
+            username=self.config_entry.data.get(CONF_USERNAME, DEFAULT_USERNAME),
+            password=self.config_entry.data[CONF_PASSWORD],
+            port=self.config_entry.data.get(CONF_PORT, DEFAULT_PORT),
             timeout=30,
             websession=async_get_clientsession(hass, verify_ssl=False),
         )
-        self.hass = hass
-        self._entry = entry
         self._unavailable_logged = False
-        self.current_unique_ids: set[tuple[str, str]] = {("dummy", "dummy_id")}
         self.update_interval = update_interval
 
     async def _connect(self) -> None:
@@ -121,7 +76,7 @@ async def _connect(self) -> None:
         self.update_interval = DEFAULT_SCAN_INTERVAL.get(
             self.api.smile_type, timedelta(seconds=60)
         )  # pw-beta options scan-interval
-        if (custom_time := self._entry.options.get(CONF_SCAN_INTERVAL)) is not None:
+        if (custom_time := self.config_entry.options.get(CONF_SCAN_INTERVAL)) is not None:
             self.update_interval = timedelta(
                 seconds=int(custom_time)
             )  # pragma: no cover  # pw-beta options
@@ -158,7 +113,4 @@ async def _async_update_data(self) -> PlugwiseData:
                 self._unavailable_logged = True
                 raise UpdateFailed("Failed to connect") from err
 
-        # Clean-up removed devices
-        cleanup_device_registry(self.hass, data)
-
         return data

custom_components/plugwise/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
   "requirements": ["plugwise==0.37.1"],
-  "version": "0.47.4"
+  "version": "0.48.0"
 }

custom_components/plugwise/util.py

@@ -4,10 +4,15 @@
 from collections.abc import Awaitable, Callable, Coroutine
 from typing import Any, Concatenate, ParamSpec, TypeVar
 
+from plugwise import PlugwiseData
 from plugwise.exceptions import PlugwiseException
 
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr
 
+from .const import DOMAIN, LOGGER
 from .entity import PlugwiseEntity
 
 _PlugwiseEntityT = TypeVar("_PlugwiseEntityT", bound=PlugwiseEntity)
@@ -37,3 +42,39 @@ async def handler(
             await self.coordinator.async_request_refresh()
 
     return handler
+
+def cleanup_device_registry(
+    hass: HomeAssistant,
+    data: PlugwiseData,
+    entry: ConfigEntry,
+) -> None:
+    """Remove deleted devices from device-registry."""
+    device_registry = dr.async_get(hass)
+    device_entries = dr.async_entries_for_config_entry(
+        device_registry, entry.entry_id
+    )
+    # via_device cannot be None, this will result in the deletion
+    # of other Plugwise Gateways when present!
+    via_device: str = ""
+    for device_entry in device_entries:
+        if not device_entry.identifiers:
+            continue  # pragma: no cover
+
+        item = list(list(device_entry.identifiers)[0])
+        if item[0] != DOMAIN:
+            continue  # pragma: no cover
+
+        # First find the Plugwise via_device, this is always the first device
+        if item[1] == data.gateway["gateway_id"]:
+            via_device = device_entry.id
+        elif ( # then remove the connected orphaned device(s)
+            device_entry.via_device_id == via_device
+            and item[1] not in list(data.devices.keys())
+        ):
+            device_registry.async_remove_device(device_entry.id)
+            LOGGER.debug(
+                "Removed %s device %s %s from device_registry",
+                DOMAIN,
+                device_entry.model,
+                item[1],
+            )

tests/components/plugwise/test_init.py

@@ -18,9 +18,11 @@
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
+from homeassistant.setup import async_setup_component
 from homeassistant.util.dt import utcnow
 
 from tests.common import MockConfigEntry, async_fire_time_changed
+from tests.typing import MockHAClientWebSocket, WebSocketGenerator
 
 LOGGER = logging.getLogger(__package__)
 
@@ -189,7 +191,7 @@ async def test_migrate_unique_id_relay(
     )
 
 
-async def test_device_removal(
+async def test_device_registry_cleanup(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_smile_adam_2: MagicMock,
@@ -209,17 +211,71 @@ async def test_device_removal(
     # Replace a Tom/Floor
     data.devices.pop("1772a4ea304041adb83f357b751341ff")
     data.devices.update(TOM)
-    device_list = list(data.devices.keys())
-    with patch(HA_PLUGWISE_SMILE_ASYNC_UPDATE, return_value=data), patch(
-        HA_PLUGWISE_SMILE, side_effect=device_list
-    ):
+    with patch(HA_PLUGWISE_SMILE_ASYNC_UPDATE, return_value=data):
         async_fire_time_changed(hass, utcnow() + timedelta(minutes=1))
         await hass.config_entries.async_reload(mock_config_entry.entry_id)
         await hass.async_block_till_done()
 
-    devices = dr.async_entries_for_config_entry(dev_reg, mock_config_entry.entry_id)
+    dev_reg = dr.async_get(hass)
     item_list = []
     for device_entry in list(dev_reg.devices.values()):
         for item in device_entry.identifiers:
             item_list.append(item[1])
+    assert "01234567890abcdefghijklmnopqrstu" in item_list
     assert "1772a4ea304041adb83f357b751341ff" not in item_list
+
+
+async def test_remove_config_entry_device(
+    hass: HomeAssistant,
+    hass_ws_client: WebSocketGenerator,
+    mock_config_entry: MockConfigEntry,
+    mock_smile_adam_2: MagicMock,
+    device_registry: dr.DeviceRegistry,
+) -> None:
+    """Test we can only remove a device that no longer exists."""
+    assert await async_setup_component(hass, "config", {})
+
+    mock_config_entry.add_to_hass(hass)
+
+    assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    device_entry = device_registry.async_get_device(
+        identifiers={
+            (
+                DOMAIN,
+                "1772a4ea304041adb83f357b751341ff",
+            )
+        },
+    )
+    assert (
+        await remove_device(
+            await hass_ws_client(hass), device_entry.id, mock_config_entry.entry_id
+        )
+        is False
+    )
+    old_device_entry = device_registry.async_get_or_create(
+        config_entry_id=mock_config_entry.entry_id,
+        identifiers={(DOMAIN, "01234567890abcdefghijklmnopqrstu")},
+    )
+    assert (
+        await remove_device(
+            await hass_ws_client(hass), old_device_entry.id, mock_config_entry.entry_id
+        )
+        is True
+    )
+
+async def remove_device(
+    ws_client: MockHAClientWebSocket, device_id: str, config_entry_id: str
+) -> bool:
+    """Remove config entry from a device."""
+    await ws_client.send_json(
+        {
+            "id": 5,
+            "type": "config/device_registry/remove_config_entry",
+            "config_entry_id": config_entry_id,
+            "device_id": device_id,
+        }
+    )
+    response = await ws_client.receive_json()
+    return response["success"]