aiohomematic 2025.8.7__py3-none-any.whl → 2025.8.9__py3-none-any.whl

aiohomematic/caches/dynamic.py

@@ -25,11 +25,13 @@ from collections.abc import Mapping
 from datetime import datetime
 import logging
 from typing import Any, Final, cast
+from urllib.parse import unquote
 
 from aiohomematic import central as hmcu
 from aiohomematic.const import (
     DP_KEY_VALUE,
     INIT_DATETIME,
+    ISO_8859_1,
     LAST_COMMAND_SEND_STORE_TIMEOUT,
     MAX_CACHE_AGE,
     NO_CACHE_ENTRY,
@@ -272,7 +274,6 @@ class CentralDataCache:
 
     __slots__ = (
         "_central",
-        "_escaped_channel_cache",
         "_refreshed_at",
         "_value_cache",
     )
@@ -283,7 +284,6 @@ class CentralDataCache:
         # { key, value}
         self._value_cache: Final[dict[Interface, Mapping[str, Any]]] = {}
         self._refreshed_at: Final[dict[Interface, datetime]] = {}
-        self._escaped_channel_cache: Final[dict[str, str]] = {}
 
     async def load(self, direct_call: bool = False, interface: Interface | None = None) -> None:
         """Fetch data from backend."""
@@ -310,7 +310,10 @@ class CentralDataCache:
 
     def add_data(self, interface: Interface, all_device_data: Mapping[str, Any]) -> None:
         """Add data to cache."""
-        self._value_cache[interface] = all_device_data
+        self._value_cache[interface] = {
+            unquote(string=k, encoding=ISO_8859_1): unquote(string=v, encoding=ISO_8859_1) if isinstance(v, str) else v
+            for k, v in all_device_data.items()
+        }
         self._refreshed_at[interface] = datetime.now()
 
     def get_data(
@@ -320,14 +323,8 @@ class CentralDataCache:
         parameter: str,
     ) -> Any:
         """Get data from cache."""
-        if not self._is_empty(interface=interface):
-            # Escape channel address only once per unique address
-            if (escaped := self._escaped_channel_cache.get(channel_address)) is None:
-                escaped = channel_address.replace(":", "%3A") if ":" in channel_address else channel_address
-                self._escaped_channel_cache[channel_address] = escaped
-            key = f"{interface}.{escaped}.{parameter}"
-            if (iface_cache := self._value_cache.get(interface)) is not None:
-                return iface_cache.get(key, NO_CACHE_ENTRY)
+        if not self._is_empty(interface=interface) and (iface_cache := self._value_cache.get(interface)) is not None:
+            return iface_cache.get(f"{interface}.{channel_address}.{parameter}", NO_CACHE_ENTRY)
         return NO_CACHE_ENTRY
 
     def clear(self, interface: Interface | None = None) -> None:
@@ -335,7 +332,6 @@ class CentralDataCache:
         if interface:
             self._value_cache[interface] = {}
             self._refreshed_at[interface] = INIT_DATETIME
-            self._escaped_channel_cache.clear()
         else:
             for _interface in self._central.interfaces:
                 self.clear(interface=_interface)

aiohomematic/caches/persistent.py

@@ -208,9 +208,15 @@ class DeviceDescriptionCache(BasePersistentCache):
 
     def add_device(self, interface_id: str, device_description: DeviceDescription) -> None:
         """Add a device to the cache."""
+        # Fast-path: If the address is not yet known, skip costly removal operations.
+        if (address := device_description["ADDRESS"]) not in self._device_descriptions[interface_id]:
+            self._raw_device_descriptions[interface_id].append(device_description)
+            self._process_device_description(interface_id=interface_id, device_description=device_description)
+            return
+        # Address exists: remove old entries before adding the new description.
         self._remove_device(
             interface_id=interface_id,
-            addresses_to_remove=[device_description["ADDRESS"]],
+            addresses_to_remove=[address],
         )
         self._raw_device_descriptions[interface_id].append(device_description)
         self._process_device_description(interface_id=interface_id, device_description=device_description)
@@ -228,23 +234,22 @@ class DeviceDescriptionCache(BasePersistentCache):
 
     def _remove_device(self, interface_id: str, addresses_to_remove: list[str]) -> None:
         """Remove a device from the cache."""
+        # Use a set for faster membership checks
+        addresses_set = set(addresses_to_remove)
         self._raw_device_descriptions[interface_id] = [
-            device
-            for device in self._raw_device_descriptions[interface_id]
-            if device["ADDRESS"] not in addresses_to_remove
+            device for device in self._raw_device_descriptions[interface_id] if device["ADDRESS"] not in addresses_set
         ]
-        for address in addresses_to_remove:
-            try:
-                if ADDRESS_SEPARATOR not in address and self._addresses[interface_id].get(address):
-                    del self._addresses[interface_id][address]
-                if self._device_descriptions[interface_id].get(address):
-                    del self._device_descriptions[interface_id][address]
-            except KeyError:
-                _LOGGER.warning("REMOVE_DEVICE failed: Unable to delete: %s", address)
-
-    def get_addresses(self, interface_id: str) -> tuple[str, ...]:
-        """Return the addresses by interface."""
-        return tuple(self._addresses[interface_id].keys())
+        addr_map = self._addresses[interface_id]
+        desc_map = self._device_descriptions[interface_id]
+        for address in addresses_set:
+            # Pop with default to avoid KeyError and try/except overhead
+            if ADDRESS_SEPARATOR not in address:
+                addr_map.pop(address, None)
+            desc_map.pop(address, None)
+
+    def get_addresses(self, interface_id: str) -> frozenset[str]:
+        """Return the addresses by interface as a set."""
+        return frozenset(self._addresses[interface_id])
 
     def get_device_descriptions(self, interface_id: str) -> Mapping[str, DeviceDescription]:
         """Return the devices by interface."""
@@ -288,9 +293,10 @@ class DeviceDescriptionCache(BasePersistentCache):
         device_address = get_device_address(address)
         self._device_descriptions[interface_id][address] = device_description
 
-        if device_address not in self._addresses[interface_id][device_address]:
-            self._addresses[interface_id][device_address].add(device_address)
-        self._addresses[interface_id][device_address].add(address)
+        # Avoid redundant membership checks; set.add is idempotent and cheaper than check+add
+        addr_set = self._addresses[interface_id][device_address]
+        addr_set.add(device_address)
+        addr_set.add(address)
 
     async def load(self) -> DataOperationResult:
         """Load device data from disk into _device_description_cache."""
@@ -420,13 +426,12 @@ class ParamsetDescriptionCache(BasePersistentCache):
     def _add_address_parameter(self, channel_address: str, paramsets: list[dict[str, Any]]) -> None:
         """Add address parameter to cache."""
         device_address, channel_no = get_split_channel_address(channel_address)
+        cache = self._address_parameter_cache
         for paramset in paramsets:
             if not paramset:
                 continue
             for parameter in paramset:
-                if (device_address, parameter) not in self._address_parameter_cache:
-                    self._address_parameter_cache[(device_address, parameter)] = set()
-                self._address_parameter_cache[(device_address, parameter)].add(channel_no)
+                cache.setdefault((device_address, parameter), set()).add(channel_no)
 
     async def load(self) -> DataOperationResult:
         """Load paramset descriptions from disk into paramset cache."""