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

aiohomematic/central/__init__.py

@@ -298,14 +298,14 @@ class CentralUnit(PayloadMixin):
         )
 
     @property
-    def interface_ids(self) -> tuple[str, ...]:
+    def interface_ids(self) -> frozenset[str]:
         """Return all associated interface ids."""
-        return tuple(self._clients)
+        return frozenset(self._clients)
 
     @property
-    def interfaces(self) -> tuple[Interface, ...]:
+    def interfaces(self) -> frozenset[Interface]:
         """Return all associated interfaces."""
-        return tuple(client.interface for client in self._clients.values())
+        return frozenset(client.interface for client in self._clients.values())
 
     @property
     def is_alive(self) -> bool:
@@ -1009,19 +1009,19 @@ class CentralUnit(PayloadMixin):
             return
 
         async with self._device_add_semaphore:
-            # We need this to avoid adding duplicates.
-            known_addresses = tuple(
-                dev_desc["ADDRESS"]
-                for dev_desc in self._device_descriptions.get_raw_device_descriptions(interface_id=interface_id)
-            )
+            # Use mapping membership to avoid rebuilding known addresses and allow O(1) checks.
+            existing_map = self._device_descriptions.get_device_descriptions(interface_id=interface_id)
             client = self._clients[interface_id]
             save_paramset_descriptions = False
             save_device_descriptions = False
             for dev_desc in device_descriptions:
                 try:
+                    address = dev_desc["ADDRESS"]
+                    # Check existence before mutating cache to ensure we detect truly new addresses.
+                    is_new_address = address not in existing_map
                     self._device_descriptions.add_device(interface_id=interface_id, device_description=dev_desc)
                     save_device_descriptions = True
-                    if dev_desc["ADDRESS"] not in known_addresses:
+                    if is_new_address:
                         await client.fetch_paramset_descriptions(device_description=dev_desc)
                         save_paramset_descriptions = True
                 except Exception as exc:  # pragma: no cover
@@ -1043,7 +1043,7 @@ class CentralUnit(PayloadMixin):
                 await self._create_devices(new_device_addresses=new_device_addresses)
 
     def _check_for_new_device_addresses(self) -> Mapping[str, set[str]]:
-        """Check if there are new devices, that needs to be created."""
+        """Check if there are new devices that need to be created."""
         new_device_addresses: dict[str, set[str]] = {}
         for interface_id in self.interface_ids:
             if not self._paramset_descriptions.has_interface_id(interface_id=interface_id):
@@ -1053,21 +1053,16 @@ class CentralUnit(PayloadMixin):
                 )
                 continue
 
-            if interface_id not in new_device_addresses:
-                new_device_addresses[interface_id] = set()
-
+            # Build the set locally and assign only if non-empty to avoid add-then-delete pattern
+            new_set: set[str] = set()
             for device_address in self._device_descriptions.get_addresses(interface_id=interface_id):
                 if device_address not in self._devices:
-                    new_device_addresses[interface_id].add(device_address)
-
-            if not new_device_addresses[interface_id]:
-                del new_device_addresses[interface_id]
+                    new_set.add(device_address)
+            if new_set:
+                new_device_addresses[interface_id] = new_set
 
         if _LOGGER.isEnabledFor(level=DEBUG):
-            count: int = 0
-            for item in new_device_addresses.values():
-                count += len(item)
-
+            count = sum(len(item) for item in new_device_addresses.values())
             _LOGGER.debug(
                 "CHECK_FOR_NEW_DEVICE_ADDRESSES: %s: %i.",
                 "Found new device addresses" if new_device_addresses else "Did not find any new device addresses",
@@ -1298,7 +1293,7 @@ class CentralUnit(PayloadMixin):
         full_format: bool = False,
         un_ignore_candidates_only: bool = False,
         use_channel_wildcard: bool = False,
-    ) -> list[str]:
+    ) -> tuple[str, ...]:
         """
         Return all parameters from VALUES paramset.
 
@@ -1368,7 +1363,7 @@ class CentralUnit(PayloadMixin):
                     else:
                         parameters.add(f"{parameter}:{paramset_key}@{model}:{channel_repr}")
 
-        return list(parameters)
+        return tuple(parameters)
 
     def _get_virtual_remote(self, device_address: str) -> Device | None:
         """Get the virtual remote for the Client."""
@@ -1811,8 +1806,8 @@ class CentralConfig:
         enable_program_scan: bool = DEFAULT_ENABLE_PROGRAM_SCAN,
         enable_sysvar_scan: bool = DEFAULT_ENABLE_SYSVAR_SCAN,
         hm_master_poll_after_send_intervals: tuple[int, ...] = DEFAULT_HM_MASTER_POLL_AFTER_SEND_INTERVALS,
-        ignore_custom_device_definition_models: tuple[str, ...] = DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
-        interfaces_requiring_periodic_refresh: tuple[Interface, ...] = INTERFACES_REQUIRING_PERIODIC_REFRESH,
+        ignore_custom_device_definition_models: frozenset[str] = DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
+        interfaces_requiring_periodic_refresh: frozenset[Interface] = INTERFACES_REQUIRING_PERIODIC_REFRESH,
         json_port: int | None = None,
         listen_ip_addr: str | None = None,
         listen_port: int | None = None,
@@ -1823,7 +1818,7 @@ class CentralConfig:
         sys_scan_interval: int = DEFAULT_SYS_SCAN_INTERVAL,
         sysvar_markers: tuple[DescriptionMarker | str, ...] = DEFAULT_SYSVAR_MARKERS,
         tls: bool = DEFAULT_TLS,
-        un_ignore_list: tuple[str, ...] = DEFAULT_UN_IGNORES,
+        un_ignore_list: frozenset[str] = DEFAULT_UN_IGNORES,
         verify_tls: bool = DEFAULT_VERIFY_TLS,
     ) -> None:
         """Init the client config."""
@@ -1838,8 +1833,8 @@ class CentralConfig:
         self.enable_sysvar_scan: Final = enable_sysvar_scan
         self.hm_master_poll_after_send_intervals: Final = hm_master_poll_after_send_intervals
         self.host: Final = host
-        self.ignore_custom_device_definition_models: Final = ignore_custom_device_definition_models
-        self.interfaces_requiring_periodic_refresh: Final = interfaces_requiring_periodic_refresh
+        self.ignore_custom_device_definition_models: Final = frozenset(ignore_custom_device_definition_models or ())
+        self.interfaces_requiring_periodic_refresh: Final = frozenset(interfaces_requiring_periodic_refresh or ())
         self.json_port: Final = json_port
         self.listen_ip_addr: Final = listen_ip_addr
         self.listen_port: Final = listen_port
@@ -1877,9 +1872,9 @@ class CentralConfig:
         return 443 if self.tls else 80
 
     @property
-    def enabled_interface_configs(self) -> tuple[hmcl.InterfaceConfig, ...]:
+    def enabled_interface_configs(self) -> frozenset[hmcl.InterfaceConfig]:
         """Return the interface configs."""
-        return tuple(ic for ic in self._interface_configs if ic.enabled is True)
+        return frozenset(ic for ic in self._interface_configs if ic.enabled is True)
 
     @property
     def use_caches(self) -> bool:

aiohomematic/const.py

@@ -9,9 +9,10 @@ from enum import Enum, IntEnum, StrEnum
 import os
 import re
 import sys
-from typing import Any, Final, NamedTuple, Required, TypedDict
+from types import MappingProxyType
+from typing import Any, Final, NamedTuple, Required, TypeAlias, TypedDict
 
-VERSION: Final = "2025.8.7"
+VERSION: Final = "2025.8.9"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -24,7 +25,7 @@ DEFAULT_ENABLE_DEVICE_FIRMWARE_CHECK: Final = False
 DEFAULT_ENABLE_PROGRAM_SCAN: Final = True
 DEFAULT_ENABLE_SYSVAR_SCAN: Final = True
 DEFAULT_HM_MASTER_POLL_AFTER_SEND_INTERVALS: Final = (5,)
-DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS: Final[tuple[str, ...]] = ()
+DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS: Final[frozenset[str]] = frozenset()
 DEFAULT_INCLUDE_INTERNAL_PROGRAMS: Final = False
 DEFAULT_INCLUDE_INTERNAL_SYSVARS: Final = True
 DEFAULT_MAX_READ_WORKERS: Final = 1
@@ -35,7 +36,7 @@ DEFAULT_PROGRAM_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
 DEFAULT_SYSVAR_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
 DEFAULT_SYS_SCAN_INTERVAL: Final = 30
 DEFAULT_TLS: Final = False
-DEFAULT_UN_IGNORES: Final[tuple[str, ...]] = ()
+DEFAULT_UN_IGNORES: Final[frozenset[str]] = frozenset()
 DEFAULT_VERIFY_TLS: Final = False
 
 # Default encoding for json service calls, persistent cache
@@ -52,22 +53,24 @@ CHANNEL_ADDRESS_PATTERN: Final = re.compile(r"^[0-9a-zA-Z-]{5,20}:[0-9]{1,3}$")
 DEVICE_ADDRESS_PATTERN: Final = re.compile(r"^[0-9a-zA-Z-]{5,20}$")
 ALLOWED_HOSTNAME_PATTERN: Final = re.compile(r"(?!-)[a-z0-9-]{1,63}(?<!-)$", re.IGNORECASE)
 HTMLTAG_PATTERN: Final = re.compile(r"<.*?>|&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-f]{1,6});")
-SCHEDULER_PROFILE_PATTERN = re.compile(
+SCHEDULER_PROFILE_PATTERN: Final = re.compile(
     r"^P[1-6]_(ENDTIME|TEMPERATURE)_(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)_([1-9]|1[0-3])$"
 )
-SCHEDULER_TIME_PATTERN = re.compile(r"^(([0-1]{0,1}[0-9])|(2[0-4])):[0-5][0-9]")
-
-ALWAYS_ENABLE_SYSVARS_BY_ID: Final = "40", "41"
-RENAME_SYSVAR_BY_NAME: Final = {
-    "${sysVarAlarmMessages}": "ALARM_MESSAGES",
-    "${sysVarPresence}": "PRESENCE",
-    "${sysVarServiceMessages}": "SERVICE_MESSAGES",
-}
+SCHEDULER_TIME_PATTERN: Final = re.compile(r"^(([0-1]{0,1}[0-9])|(2[0-4])):[0-5][0-9]")
+
+ALWAYS_ENABLE_SYSVARS_BY_ID: Final[frozenset[str]] = frozenset({"40", "41"})
+RENAME_SYSVAR_BY_NAME: Final[Mapping[str, str]] = MappingProxyType(
+    {
+        "${sysVarAlarmMessages}": "ALARM_MESSAGES",
+        "${sysVarPresence}": "PRESENCE",
+        "${sysVarServiceMessages}": "SERVICE_MESSAGES",
+    }
+)
 
-SYSVAR_ENABLE_DEFAULT: Final = "40", "41"
+SYSVAR_ENABLE_DEFAULT: Final[frozenset[str]] = frozenset({"40", "41"})
 
 ADDRESS_SEPARATOR: Final = ":"
-BLOCK_LOG_TIMEOUT = 60
+BLOCK_LOG_TIMEOUT: Final = 60
 CACHE_PATH: Final = "cache"
 CONF_PASSWORD: Final = "password"
 CONF_USERNAME: Final = "username"
@@ -79,7 +82,7 @@ DEVICE_DESCRIPTIONS_DIR: Final = "export_device_descriptions"
 DEVICE_FIRMWARE_CHECK_INTERVAL: Final = 21600  # 6h
 DEVICE_FIRMWARE_DELIVERING_CHECK_INTERVAL: Final = 3600  # 1h
 DEVICE_FIRMWARE_UPDATING_CHECK_INTERVAL: Final = 300  # 5m
-DUMMY_SERIAL = "SN0815"
+DUMMY_SERIAL: Final = "SN0815"
 FILE_DEVICES: Final = "homematic_devices.json"
 FILE_PARAMSETS: Final = "homematic_paramsets.json"
 HUB_PATH: Final = "hub"
@@ -87,7 +90,7 @@ IDENTIFIER_SEPARATOR: Final = "@"
 INIT_DATETIME: Final = datetime.strptime("01.01.1970 00:00:00", DATETIME_FORMAT)
 IP_ANY_V4: Final = "0.0.0.0"
 JSON_SESSION_AGE: Final = 90
-KWARGS_ARG_DATA_POINT = "data_point"
+KWARGS_ARG_DATA_POINT: Final = "data_point"
 LAST_COMMAND_SEND_STORE_TIMEOUT: Final = 60
 LOCAL_HOST: Final = "127.0.0.1"
 MAX_CACHE_AGE: Final = 10
@@ -113,7 +116,7 @@ WAIT_FOR_CALLBACK: Final[int | None] = None
 SCHEDULER_NOT_STARTED_SLEEP: Final = 0.05 if _TEST_SPEEDUP else 10
 SCHEDULER_LOOP_SLEEP: Final = 0.05 if _TEST_SPEEDUP else 5
 
-CALLBACK_WARN_INTERVAL = CONNECTION_CHECKER_INTERVAL * 40
+CALLBACK_WARN_INTERVAL: Final = CONNECTION_CHECKER_INTERVAL * 40
 
 # Path
 PROGRAM_SET_PATH_ROOT: Final = "program/set"
@@ -125,7 +128,7 @@ SYSVAR_STATE_PATH_ROOT: Final = "sysvar/status"
 VIRTDEV_SET_PATH_ROOT: Final = "virtdev/set"
 VIRTDEV_STATE_PATH_ROOT: Final = "virtdev/status"
 
-CALLBACK_TYPE = Callable[[], None] | None
+CALLBACK_TYPE: TypeAlias = Callable[[], None] | None
 
 
 class Backend(StrEnum):
@@ -536,22 +539,26 @@ class ParameterType(StrEnum):
     EMPTY = ""
 
 
-CLICK_EVENTS: Final[tuple[Parameter, ...]] = (
-    Parameter.PRESS,
-    Parameter.PRESS_CONT,
-    Parameter.PRESS_LOCK,
-    Parameter.PRESS_LONG,
-    Parameter.PRESS_LONG_RELEASE,
-    Parameter.PRESS_LONG_START,
-    Parameter.PRESS_SHORT,
-    Parameter.PRESS_UNLOCK,
+CLICK_EVENTS: Final[frozenset[Parameter]] = frozenset(
+    {
+        Parameter.PRESS,
+        Parameter.PRESS_CONT,
+        Parameter.PRESS_LOCK,
+        Parameter.PRESS_LONG,
+        Parameter.PRESS_LONG_RELEASE,
+        Parameter.PRESS_LONG_START,
+        Parameter.PRESS_SHORT,
+        Parameter.PRESS_UNLOCK,
+    }
 )
 
 DEVICE_ERROR_EVENTS: Final[tuple[Parameter, ...]] = (Parameter.ERROR, Parameter.SENSOR_ERROR)
 
-DATA_POINT_EVENTS: Final[tuple[EventType, ...]] = (
-    EventType.IMPULSE,
-    EventType.KEYPRESS,
+DATA_POINT_EVENTS: Final[frozenset[EventType]] = frozenset(
+    {
+        EventType.IMPULSE,
+        EventType.KEYPRESS,
+    }
 )
 
 
@@ -567,26 +574,32 @@ class DataPointKey(NamedTuple):
 type DP_KEY_VALUE = tuple[DataPointKey, Any]
 type SYSVAR_TYPE = bool | float | int | str | None
 
-HMIP_FIRMWARE_UPDATE_IN_PROGRESS_STATES: Final[tuple[DeviceFirmwareState, ...]] = (
-    DeviceFirmwareState.DO_UPDATE_PENDING,
-    DeviceFirmwareState.PERFORMING_UPDATE,
+HMIP_FIRMWARE_UPDATE_IN_PROGRESS_STATES: Final[frozenset[DeviceFirmwareState]] = frozenset(
+    {
+        DeviceFirmwareState.DO_UPDATE_PENDING,
+        DeviceFirmwareState.PERFORMING_UPDATE,
+    }
 )
 
-HMIP_FIRMWARE_UPDATE_READY_STATES: Final[tuple[DeviceFirmwareState, ...]] = (
-    DeviceFirmwareState.READY_FOR_UPDATE,
-    DeviceFirmwareState.DO_UPDATE_PENDING,
-    DeviceFirmwareState.PERFORMING_UPDATE,
+HMIP_FIRMWARE_UPDATE_READY_STATES: Final[frozenset[DeviceFirmwareState]] = frozenset(
+    {
+        DeviceFirmwareState.READY_FOR_UPDATE,
+        DeviceFirmwareState.DO_UPDATE_PENDING,
+        DeviceFirmwareState.PERFORMING_UPDATE,
+    }
 )
 
-IMPULSE_EVENTS: Final[tuple[Parameter, ...]] = (Parameter.SEQUENCE_OK,)
+IMPULSE_EVENTS: Final[frozenset[Parameter]] = frozenset({Parameter.SEQUENCE_OK})
 
-KEY_CHANNEL_OPERATION_MODE_VISIBILITY: Final[Mapping[str, tuple[str, ...]]] = {
-    Parameter.STATE: ("BINARY_BEHAVIOR",),
-    Parameter.PRESS_LONG: ("KEY_BEHAVIOR", "SWITCH_BEHAVIOR"),
-    Parameter.PRESS_LONG_RELEASE: ("KEY_BEHAVIOR", "SWITCH_BEHAVIOR"),
-    Parameter.PRESS_LONG_START: ("KEY_BEHAVIOR", "SWITCH_BEHAVIOR"),
-    Parameter.PRESS_SHORT: ("KEY_BEHAVIOR", "SWITCH_BEHAVIOR"),
-}
+KEY_CHANNEL_OPERATION_MODE_VISIBILITY: Final[Mapping[str, frozenset[str]]] = MappingProxyType(
+    {
+        Parameter.STATE: frozenset({"BINARY_BEHAVIOR"}),
+        Parameter.PRESS_LONG: frozenset({"KEY_BEHAVIOR", "SWITCH_BEHAVIOR"}),
+        Parameter.PRESS_LONG_RELEASE: frozenset({"KEY_BEHAVIOR", "SWITCH_BEHAVIOR"}),
+        Parameter.PRESS_LONG_START: frozenset({"KEY_BEHAVIOR", "SWITCH_BEHAVIOR"}),
+        Parameter.PRESS_SHORT: frozenset({"KEY_BEHAVIOR", "SWITCH_BEHAVIOR"}),
+    }
+)
 
 HUB_CATEGORIES: Final[tuple[DataPointCategory, ...]] = (
     DataPointCategory.HUB_BINARY_SENSOR,
@@ -616,42 +629,54 @@ CATEGORIES: Final[tuple[DataPointCategory, ...]] = (
     DataPointCategory.VALVE,
 )
 
-PRIMARY_CLIENT_CANDIDATE_INTERFACES: Final = (
-    Interface.HMIP_RF,
-    Interface.BIDCOS_RF,
-    Interface.BIDCOS_WIRED,
+PRIMARY_CLIENT_CANDIDATE_INTERFACES: Final[frozenset[Interface]] = frozenset(
+    {
+        Interface.HMIP_RF,
+        Interface.BIDCOS_RF,
+        Interface.BIDCOS_WIRED,
+    }
 )
 
-RELEVANT_INIT_PARAMETERS: Final[tuple[Parameter, ...]] = (
-    Parameter.CONFIG_PENDING,
-    Parameter.STICKY_UN_REACH,
-    Parameter.UN_REACH,
+RELEVANT_INIT_PARAMETERS: Final[frozenset[Parameter]] = frozenset(
+    {
+        Parameter.CONFIG_PENDING,
+        Parameter.STICKY_UN_REACH,
+        Parameter.UN_REACH,
+    }
 )
 
-INTERFACES_SUPPORTING_FIRMWARE_UPDATES: Final[tuple[Interface, ...]] = (
-    Interface.BIDCOS_RF,
-    Interface.BIDCOS_WIRED,
-    Interface.HMIP_RF,
+INTERFACES_SUPPORTING_FIRMWARE_UPDATES: Final[frozenset[Interface]] = frozenset(
+    {
+        Interface.BIDCOS_RF,
+        Interface.BIDCOS_WIRED,
+        Interface.HMIP_RF,
+    }
 )
 
-INTERFACES_SUPPORTING_XML_RPC: Final[tuple[Interface, ...]] = (
-    Interface.BIDCOS_RF,
-    Interface.BIDCOS_WIRED,
-    Interface.HMIP_RF,
-    Interface.VIRTUAL_DEVICES,
+INTERFACES_SUPPORTING_XML_RPC: Final[frozenset[Interface]] = frozenset(
+    {
+        Interface.BIDCOS_RF,
+        Interface.BIDCOS_WIRED,
+        Interface.HMIP_RF,
+        Interface.VIRTUAL_DEVICES,
+    }
 )
 
-INTERFACES_REQUIRING_PERIODIC_REFRESH: Final[tuple[Interface, ...]] = (
-    Interface.CCU_JACK,
-    Interface.CUXD,
+INTERFACES_REQUIRING_PERIODIC_REFRESH: Final[frozenset[Interface]] = frozenset(
+    {
+        Interface.CCU_JACK,
+        Interface.CUXD,
+    }
 )
 
 DEFAULT_USE_PERIODIC_SCAN_FOR_INTERFACES: Final = True
 
-IGNORE_FOR_UN_IGNORE_PARAMETERS: Final[tuple[Parameter, ...]] = (
-    Parameter.CONFIG_PENDING,
-    Parameter.STICKY_UN_REACH,
-    Parameter.UN_REACH,
+IGNORE_FOR_UN_IGNORE_PARAMETERS: Final[frozenset[Parameter]] = frozenset(
+    {
+        Parameter.CONFIG_PENDING,
+        Parameter.STICKY_UN_REACH,
+        Parameter.UN_REACH,
+    }
 )
 
 
@@ -659,12 +684,14 @@ IGNORE_FOR_UN_IGNORE_PARAMETERS: Final[tuple[Parameter, ...]] = (
 _IGNORE_ON_INITIAL_LOAD_PARAMETERS_END_RE: Final = re.compile(r".*(_ERROR)$")
 # Ignore Parameter on initial load that start with
 _IGNORE_ON_INITIAL_LOAD_PARAMETERS_START_RE: Final = re.compile(r"^(ERROR_|RSSI_)")
-_IGNORE_ON_INITIAL_LOAD_PARAMETERS: Final = (
-    Parameter.DUTY_CYCLE,
-    Parameter.DUTYCYCLE,
-    Parameter.LOW_BAT,
-    Parameter.LOWBAT,
-    Parameter.OPERATING_VOLTAGE,
+_IGNORE_ON_INITIAL_LOAD_PARAMETERS: Final[frozenset[Parameter]] = frozenset(
+    {
+        Parameter.DUTY_CYCLE,
+        Parameter.DUTYCYCLE,
+        Parameter.LOW_BAT,
+        Parameter.LOWBAT,
+        Parameter.OPERATING_VOLTAGE,
+    }
 )
 
 

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/model/calculated/data_point.py

@@ -280,6 +280,10 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         """Generate the usage for the data point."""
         return DataPointUsage.DATA_POINT
 
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+        return f"{self._category}/{self._channel.device.model}/{self._calculated_parameter}"
+
     async def load_data_point_value(self, call_source: CallSource, direct_call: bool = False) -> None:
         """Init the data point values."""
         for dp in self._readable_data_points:
@@ -300,7 +304,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
     @property
     def _should_fire_data_point_updated_callback(self) -> bool:
         """Check if a data point has been updated or refreshed."""
-        if self.fired_recently:  # pylint: disable=using-constant-test
+        if self.fired_recently:
             return False
 
         if (relevant_values_data_point := self._relevant_values_data_points) is not None and len(

aiohomematic/model/custom/data_point.py

@@ -177,6 +177,10 @@ class CustomDataPoint(BaseDataPoint):
             return DataPointUsage.CDP_PRIMARY
         return DataPointUsage.CDP_SECONDARY
 
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+        return f"{self._category}/{self._channel.device.model}/{self.data_point_name_postfix}"
+
     async def load_data_point_value(self, call_source: CallSource, direct_call: bool = False) -> None:
         """Init the data point values."""
         for dp in self._readable_data_points:

aiohomematic/model/data_point.py

@@ -146,6 +146,7 @@ class CallbackDataPoint(ABC):
         "_modified_at",
         "_path_data",
         "_refreshed_at",
+        "_signature",
         "_temporary_modified_at",
         "_temporary_refreshed_at",
         "_unique_id",
@@ -164,6 +165,7 @@ class CallbackDataPoint(ABC):
         self._fired_at: datetime = INIT_DATETIME
         self._modified_at: datetime = INIT_DATETIME
         self._refreshed_at: datetime = INIT_DATETIME
+        self._signature: Final = self._get_signature()
         self._temporary_modified_at: datetime = INIT_DATETIME
         self._temporary_refreshed_at: datetime = INIT_DATETIME
 
@@ -252,6 +254,11 @@ class CallbackDataPoint(ABC):
     def name(self) -> str:
         """Return the name of the data_point."""
 
+    @property
+    def signature(self) -> str:
+        """Return the data_point signature."""
+        return self._signature
+
     @config_property
     def unique_id(self) -> str:
         """Return the unique_id."""
@@ -325,6 +332,10 @@ class CallbackDataPoint(ABC):
     def _get_path_data(self) -> PathData:
         """Return the path data."""
 
+    @abstractmethod
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+
     def _unregister_data_point_updated_callback(self, cb: Callable, custom_id: str) -> None:
         """Unregister data_point updated callback."""
         if cb in self._data_point_updated_callbacks:
@@ -840,6 +851,10 @@ class BaseParameterDataPoint[
             return multiplier
         return DEFAULT_MULTIPLIER
 
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+        return f"{self._category}/{self._channel.device.model}/{self._parameter}"
+
     @abstractmethod
     async def event(self, value: Any, received_at: datetime | None = None) -> None:
         """Handle event for which this handler has subscribed."""
@@ -861,9 +876,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,
             ),