aiohomematic 2025.8.7__tar.gz → 2025.8.8__tar.gz

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.8.7
+Version: 2025.8.8
 Summary: Homematic interface for Home Assistant running on Python 3.
 Home-page: https://github.com/sukramj/aiohomematic
 Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/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-2025.8.7 → aiohomematic-2025.8.8}/aiohomematic/const.py

@@ -11,7 +11,7 @@ import re
 import sys
 from typing import Any, Final, NamedTuple, Required, TypedDict
 
-VERSION: Final = "2025.8.7"
+VERSION: Final = "2025.8.8"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/aiohomematic/model/calculated/__init__.py

@@ -60,6 +60,6 @@ _LOGGER: Final = logging.getLogger(__name__)
 @inspector()
 def create_calculated_data_points(channel: hmd.Channel) -> None:
     """Decides which data point category should be used, and creates the required data points."""
-    for cdp in _CALCULATED_DATA_POINTS:
-        if cdp.is_relevant_for_model(channel=channel):
-            channel.add_data_point(data_point=cdp(channel=channel))
+    for dp in _CALCULATED_DATA_POINTS:
+        if dp.is_relevant_for_model(channel=channel):
+            channel.add_data_point(data_point=dp(channel=channel))

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/aiohomematic/model/data_point.py

@@ -861,9 +861,7 @@ class BaseParameterDataPoint[
 
         self.write_value(
             value=await self._device.value_cache.get_value(
-                channel_address=self._channel.address,
-                paramset_key=self._paramset_key,
-                parameter=self._parameter,
+                dpk=self.dpk,
                 call_source=call_source,
                 direct_call=direct_call,
             ),

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/aiohomematic/model/device.py

@@ -1146,121 +1146,90 @@ class _ValueCache:
 
     async def get_value(
         self,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        parameter: str,
+        dpk: DataPointKey,
         call_source: CallSource,
         direct_call: bool = False,
     ) -> Any:
         """Load data."""
+
         async with self._sema_get_or_load_value:
-            if (
-                direct_call is False
-                and (
-                    cached_value := self._get_value_from_cache(
-                        channel_address=channel_address,
-                        paramset_key=paramset_key,
-                        parameter=parameter,
-                    )
-                )
-                != NO_CACHE_ENTRY
-            ):
+            if direct_call is False and (cached_value := self._get_value_from_cache(dpk=dpk)) != NO_CACHE_ENTRY:
                 return NO_CACHE_ENTRY if cached_value == self._NO_VALUE_CACHE_ENTRY else cached_value
 
-            value_dict: dict[str, Any] = {parameter: self._NO_VALUE_CACHE_ENTRY}
+            value_dict: dict[str, Any] = {dpk.parameter: self._NO_VALUE_CACHE_ENTRY}
             try:
-                value_dict = await self._get_values_for_cache(
-                    channel_address=channel_address,
-                    paramset_key=paramset_key,
-                    parameter=parameter,
-                )
+                value_dict = await self._get_values_for_cache(dpk=dpk)
             except BaseHomematicException as bhexc:
                 _LOGGER.debug(
                     "GET_OR_LOAD_VALUE: Failed to get data for %s, %s, %s, %s: %s",
                     self._device.model,
-                    channel_address,
-                    parameter,
+                    dpk.channel_address,
+                    dpk.parameter,
                     call_source,
                     extract_exc_args(exc=bhexc),
                 )
             for d_parameter, d_value in value_dict.items():
                 self._add_entry_to_device_cache(
-                    channel_address=channel_address,
-                    paramset_key=paramset_key,
-                    parameter=d_parameter,
+                    dpk=DataPointKey(
+                        interface_id=dpk.interface_id,
+                        channel_address=dpk.channel_address,
+                        paramset_key=dpk.paramset_key,
+                        parameter=d_parameter,
+                    ),
                     value=d_value,
                 )
             return (
                 NO_CACHE_ENTRY
-                if (value := value_dict.get(parameter)) and value == self._NO_VALUE_CACHE_ENTRY
+                if (value := value_dict.get(dpk.parameter)) and value == self._NO_VALUE_CACHE_ENTRY
                 else value
             )
 
-    async def _get_values_for_cache(
-        self, channel_address: str, paramset_key: ParamsetKey, parameter: str
-    ) -> dict[str, Any]:
+    async def _get_values_for_cache(self, dpk: DataPointKey) -> dict[str, Any]:
         """Return a value from CCU to store in cache."""
         if not self._device.available:
             _LOGGER.debug(
                 "GET_VALUES_FOR_CACHE failed: device %s (%s) is not available", self._device.name, self._device.address
             )
             return {}
-        if paramset_key == ParamsetKey.VALUES:
+        if dpk.paramset_key == ParamsetKey.VALUES:
             return {
-                parameter: await self._device.client.get_value(
-                    channel_address=channel_address,
-                    paramset_key=paramset_key,
-                    parameter=parameter,
+                dpk.parameter: await self._device.client.get_value(
+                    channel_address=dpk.channel_address,
+                    paramset_key=dpk.paramset_key,
+                    parameter=dpk.parameter,
                     call_source=CallSource.HM_INIT,
                 )
             }
         return await self._device.client.get_paramset(
-            address=channel_address, paramset_key=paramset_key, call_source=CallSource.HM_INIT
+            address=dpk.channel_address, paramset_key=dpk.paramset_key, call_source=CallSource.HM_INIT
         )
 
-    def _add_entry_to_device_cache(
-        self, channel_address: str, paramset_key: ParamsetKey, parameter: str, value: Any
-    ) -> None:
+    def _add_entry_to_device_cache(self, dpk: DataPointKey, value: Any) -> None:
         """Add value to cache."""
-        key = DataPointKey(
-            interface_id=self._device.interface_id,
-            channel_address=channel_address,
-            paramset_key=paramset_key,
-            parameter=parameter,
-        )
         # write value to cache even if an exception has occurred
         # to avoid repetitive calls to CCU within max_age
-        self._device_cache[key] = CacheEntry(value=value, refresh_at=datetime.now())
+        self._device_cache[dpk] = CacheEntry(value=value, refresh_at=datetime.now())
 
     def _get_value_from_cache(
         self,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        parameter: str,
+        dpk: DataPointKey,
     ) -> Any:
         """Load data from caches."""
         # Try to get data from central cache
         if (
-            paramset_key == ParamsetKey.VALUES
+            dpk.paramset_key == ParamsetKey.VALUES
             and (
                 global_value := self._device.central.data_cache.get_data(
                     interface=self._device.interface,
-                    channel_address=channel_address,
-                    parameter=parameter,
+                    channel_address=dpk.channel_address,
+                    parameter=dpk.parameter,
                 )
             )
             != NO_CACHE_ENTRY
         ):
             return global_value
 
-        # Try to get data from device cache
-        key = DataPointKey(
-            interface_id=self._device.interface_id,
-            channel_address=channel_address,
-            paramset_key=paramset_key,
-            parameter=parameter,
-        )
-        if (cache_entry := self._device_cache.get(key, CacheEntry.empty())) and cache_entry.is_valid:
+        if (cache_entry := self._device_cache.get(dpk, CacheEntry.empty())) and cache_entry.is_valid:
             return cache_entry.value
         return NO_CACHE_ENTRY
 

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/aiohomematic/model/hub/__init__.py

@@ -289,21 +289,17 @@ class Hub:
 
     def _identify_missing_program_ids(self, programs: tuple[ProgramData, ...]) -> set[str]:
         """Identify missing programs."""
-        return {
-            program_dp.pid
-            for program_dp in self._central.program_data_points
-            if program_dp.pid not in [x.pid for x in programs]
-        }
+        return {dp.pid for dp in self._central.program_data_points if dp.pid not in [x.pid for x in programs]}
 
     def _identify_missing_variable_ids(self, variables: tuple[SystemVariableData, ...]) -> set[str]:
         """Identify missing variables."""
         variable_ids: dict[str, bool] = {x.vid: x.extended_sysvar for x in variables}
         missing_variable_ids: list[str] = []
-        for svdp in self._central.sysvar_data_points:
-            if svdp.data_type == SysvarType.STRING:
+        for dp in self._central.sysvar_data_points:
+            if dp.data_type == SysvarType.STRING:
                 continue
-            if (vid := svdp.vid) is not None and (
-                vid not in variable_ids or (svdp.is_extended is not variable_ids.get(vid))
+            if (vid := dp.vid) is not None and (
+                vid not in variable_ids or (dp.is_extended is not variable_ids.get(vid))
             ):
                 missing_variable_ids.append(vid)
         return set(missing_variable_ids)

aiohomematic-2025.8.8/aiohomematic/rega_scripts/fetch_all_device_data.fn

@@ -0,0 +1,92 @@
+!# fetch_all_device_data.fn v2.2
+!# This script fetches all device data required to initialize the entities without affecting the duty cycle.
+!#
+!# Original script: https://github.com/ioBroker/ioBroker.hm-rega/blob/master/regascripts/datapoints.fn
+!# datapoints.fn 1.9
+!# 3'2013-9'2014 hobbyquaker https://github.com/hobbyquaker
+!#
+!# Dieses Homematic-Script gibt eine Liste aller Datenpunkte, die zur Laufzeit einen validen Zeitstempel haben, als JSON String aus.
+!#
+!# modified by: SukramJ https://github.com/SukramJ && Baxxy13 https://github.com/Baxxy13
+!# v2.2 - 09/2023
+!#
+!# Das Interface wird durch die Integration an 'sUse_Interface' übergeben.
+!# Nutzbare Interfaces: BidCos-RF, BidCos-Wired, HmIP-RF, VirtualDevices
+!# Zum Testen direkt auf der Homematic-Zentrale muss das Interface wie folgt eingetragen werden: sUse_Interface = "HmIP-RF";
+
+string sUse_Interface = "##interface##";
+string sDevId;
+string sChnId;
+string sDPId;
+var vDPValue;
+boolean bDPFirst = true;
+object oInterface = interfaces.Get(sUse_Interface);
+
+Write('{');
+if (oInterface) {
+    integer iInterface_ID = interfaces.Get(sUse_Interface).ID();
+    string sAllDevices = dom.GetObject(ID_DEVICES).EnumUsedIDs();
+    foreach (sDevId, sAllDevices) {
+        object oDevice = dom.GetObject(sDevId);
+        if ((oDevice) && (oDevice.ReadyConfig()) && (oDevice.Interface() == iInterface_ID)) {
+            foreach (sChnId, oDevice.Channels()) {
+                object oChannel = dom.GetObject(sChnId);
+                if (oChannel) {
+                    var oDPs = oChannel.DPs();
+                    if (oDPs) {
+                        foreach(sDPId, oDPs.EnumUsedIDs()) {
+                            object oDP = dom.GetObject(sDPId);
+                            if (oDP && oDP.Timestamp()) {
+                                if (oDP.TypeName() != "VARDP") {
+                                    integer sValueType = oDP.ValueType();
+                                    boolean bHasValue = false;
+                                    string sValue;
+                                    string sID = oDP.Name().UriEncode();
+                                    if (sValueType == 20) {
+                                        sValue = oDP.Value().UriEncode();
+                                        bHasValue = true;
+                                    } else {
+                                        vDPValue = oDP.Value();
+                                        if (sValueType == 2) {
+                                            if (vDPValue) {
+                                                sValue = "true";
+                                            } else {
+                                                sValue = "false";
+                                            }
+                                            bHasValue = true;
+                                        } else {
+                                            if (vDPValue == "") {
+                                                sValue = "0";
+                                            } else {
+                                                sValue = vDPValue;
+                                            }
+                                            bHasValue = true;
+                                        }
+                                    }
+                                    if (bHasValue) {
+                                        if (bDPFirst) {
+                                            bDPFirst = false;
+                                        } else {
+                                            WriteLine(',');
+                                        }
+                                        Write('"');
+                                        Write(sID);
+                                        Write('":');
+                                        if (sValueType == 20) {
+                                            Write('"');
+                                            Write(sValue);
+                                            Write('"');
+                                        } else {
+                                            Write(sValue);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+Write('}');

{aiohomematic-2025.8.7 → aiohomematic-2025.8.8}/aiohomematic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.8.7
+Version: 2025.8.8
 Summary: Homematic interface for Home Assistant running on Python 3.
 Home-page: https://github.com/sukramj/aiohomematic
 Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>

aiohomematic-2025.8.7/aiohomematic/rega_scripts/fetch_all_device_data.fn

@@ -1,75 +0,0 @@
-!# fetch_all_device_data.fn v2.2
-!# This script fetches all device data required to initialize the entities without affecting the duty cycle.
-!#
-!# Original script: https://github.com/ioBroker/ioBroker.hm-rega/blob/master/regascripts/datapoints.fn
-!# datapoints.fn 1.9
-!# 3'2013-9'2014 hobbyquaker https://github.com/hobbyquaker
-!#
-!# Dieses Homematic-Script gibt eine Liste aller Datenpunkte, die zur Laufzeit einen validen Zeitstempel haben, als JSON String aus.
-!#
-!# modified by: SukramJ https://github.com/SukramJ && Baxxy13 https://github.com/Baxxy13
-!# v2.2 - 09/2023
-!#
-!# Das Interface wird durch die Integration an 'sUse_Interface' übergeben.
-!# Nutzbare Interfaces: BidCos-RF, BidCos-Wired, HmIP-RF, VirtualDevices
-!# Zum Testen direkt auf der Homematic-Zentrale muss das Interface wie folgt eingetragen werden: sUse_Interface = "HmIP-RF";
-
-string sUse_Interface = "##interface##";
-string sDevId;
-string sChnId;
-string sDPId;
-string sDPId;
-var vDPValue;
-boolean bDPFirst = true;
-object oInterface = interfaces.Get(sUse_Interface);
-
-Write('{');
-if (oInterface) {
-    integer iInterface_ID = interfaces.Get(sUse_Interface).ID();
-    string sAllDevices = dom.GetObject(ID_DEVICES).EnumUsedIDs();
-    foreach (sDevId, sAllDevices) {
-       object oDevice = dom.GetObject(sDevId);
-        if ((oDevice) && (oDevice.ReadyConfig()) && (oDevice.Interface() == iInterface_ID)) {
-            foreach (sChnId, oDevice.Channels()) {
-                object oChannel = dom.GetObject(sChnId);
-                foreach(sDPId, oChannel.DPs().EnumUsedIDs()) {
-                    object oDP = dom.GetObject(sDPId);
-                    if (oDP && oDP.Timestamp()) {
-                        if (oDP.TypeName() != "VARDP") {
-                            if (bDPFirst) {
-                              bDPFirst = false;
-                            } else {
-                              WriteLine(',');
-                            }
-                            integer sValueType = oDP.ValueType();
-                            Write('"');
-                            WriteURL(oDP.Name());
-                            Write('":');
-                            if (sValueType == 20) {
-                                Write('"');
-                                WriteURL(oDP.Value());
-                                Write('"');
-                            } else {
-                                vDPValue = oDP.Value();
-                                if (sValueType == 2) {
-                                    if (vDPValue) {
-                                        Write("true");
-                                    } else {
-                                        Write("false");
-                                    }
-                                } else {
-                                   if (vDPValue == "") {
-                                        Write("0");
-                                   } else {
-                                        Write(vDPValue);
-                                   }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-Write('}');