aiohomematic 2025.9.3__py3-none-any.whl → 2025.9.4__py3-none-any.whl

aiohomematic/client/json_rpc.py

@@ -263,7 +263,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return delta.seconds < JSON_SESSION_AGE
 
     async def _do_login(self) -> str | None:
-        """Login to CCU and return session."""
+        """Login to the backend and return session."""
         if not self._has_credentials:
             _LOGGER.warning("DO_LOGIN failed: No credentials set")
             return None
@@ -398,7 +398,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         if not self._has_credentials:
             raise ClientException("No credentials set")
         if self._supported_methods and method not in self._supported_methods:
-            raise UnsupportedException(f"POST: method '{method} not supported by backend.")
+            raise UnsupportedException(f"POST: method '{method} not supported by the backend.")
 
         params = _get_params(session_id=session_id, extra_params=extra_params, use_default_params=use_default_params)
 
@@ -492,7 +492,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
             message = f"ClientConnectorCertificateError[{cccerr}]"
             if self._tls is False and cccerr.ssl is True:
                 message = (
-                    f"{message}. Possible reason: 'Automatic forwarding to HTTPS' is enabled in backend, "
+                    f"{message}. Possible reason: 'Automatic forwarding to HTTPS' is enabled in the backend, "
                     f"but this integration is not configured to use TLS"
                 )
             log_boundary_error(
@@ -540,7 +540,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
             return orjson.loads((await response.read()).decode(encoding=UTF_8))
 
     async def logout(self) -> None:
-        """Logout of CCU."""
+        """Logout of the backend."""
         try:
             await self._looper.block_till_done()
             await self._do_logout(self._session_id)
@@ -553,7 +553,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
             await self._client_session.close()
 
     async def _do_logout(self, session_id: str | None) -> None:
-        """Logout of CCU."""
+        """Logout of the backend."""
         if not session_id:
             _LOGGER.debug("DO_LOGOUT: Not logged in. Not logging out.")
             return
@@ -580,7 +580,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         self._session_id = None
 
     async def execute_program(self, pid: str) -> bool:
-        """Execute a program on CCU / Homegear."""
+        """Execute a program on the backend."""
         params = {
             _JsonKey.ID: pid,
         }
@@ -597,7 +597,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return True
 
     async def set_program_state(self, pid: str, state: bool) -> bool:
-        """Set the program state on CCU / Homegear."""
+        """Set the program state on the backend."""
         params = {
             _JsonKey.ID: pid,
             _JsonKey.STATE: "1" if state else "0",
@@ -614,7 +614,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return True
 
     async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
-        """Set a system variable on CCU / Homegear."""
+        """Set a system variable on the backend."""
         params = {_JsonKey.NAME: legacy_name, _JsonKey.VALUE: value}
         if isinstance(value, bool):
             params[_JsonKey.VALUE] = int(value)
@@ -640,7 +640,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return True
 
     async def delete_system_variable(self, name: str) -> bool:
-        """Delete a system variable from CCU / Homegear."""
+        """Delete a system variable from the backend."""
         params = {_JsonKey.NAME: name}
         response = await self._post(
             method=_JsonRpcMethod.SYSVAR_DELETE_SYSVAR_BY_NAME,
@@ -655,7 +655,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return True
 
     async def get_system_variable(self, name: str) -> Any:
-        """Get single system variable from CCU / Homegear."""
+        """Get single system variable from the backend."""
         params = {_JsonKey.NAME: name}
         response = await self._post(
             method=_JsonRpcMethod.SYSVAR_GET_VALUE_BY_NAME,
@@ -668,7 +668,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
     async def get_all_system_variables(
         self, markers: tuple[DescriptionMarker | str, ...]
     ) -> tuple[SystemVariableData, ...]:
-        """Get all system variables from CCU / Homegear."""
+        """Get all system variables from the backend."""
         variables: list[SystemVariableData] = []
 
         response = await self._post(
@@ -760,7 +760,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return tuple(variables)
 
     async def _get_program_descriptions(self) -> Mapping[str, str]:
-        """Get all program descriptions from CCU via script."""
+        """Get all program descriptions from the backend via script."""
         descriptions: dict[str, str] = {}
         try:
             response = await self._post_script(script_name=RegaScript.GET_PROGRAM_DESCRIPTIONS)
@@ -779,7 +779,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return descriptions
 
     async def _get_system_variable_descriptions(self) -> Mapping[str, str]:
-        """Get all system variable descriptions from CCU via script."""
+        """Get all system variable descriptions from the backend via script."""
         descriptions: dict[str, str] = {}
         try:
             response = await self._post_script(script_name=RegaScript.GET_SYSTEM_VARIABLE_DESCRIPTIONS)
@@ -798,7 +798,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return descriptions
 
     async def get_all_channel_ids_room(self) -> Mapping[str, set[str]]:
-        """Get all channel_ids per room from CCU / Homegear."""
+        """Get all channel_ids per room from the backend."""
         channel_ids_room: dict[str, set[str]] = {}
 
         response = await self._post(
@@ -821,7 +821,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return channel_ids_room
 
     async def get_all_channel_ids_function(self) -> Mapping[str, set[str]]:
-        """Get all channel_ids per function from CCU / Homegear."""
+        """Get all channel_ids per function from the backend."""
         channel_ids_function: dict[str, set[str]] = {}
 
         response = await self._post(
@@ -844,7 +844,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return channel_ids_function
 
     async def get_device_description(self, interface: Interface, address: str) -> DeviceDescription | None:
-        """Get device descriptions from CCU."""
+        """Get device descriptions from the backend."""
         device_description: DeviceDescription | None = None
         params = {
             _JsonKey.INTERFACE: interface,
@@ -906,7 +906,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
     async def get_paramset(
         self, interface: Interface, address: str, paramset_key: ParamsetKey | str
     ) -> dict[str, Any] | None:
-        """Get paramset from CCU."""
+        """Get paramset from the backend."""
         paramset: dict[str, Any] = {}
         params = {
             _JsonKey.INTERFACE: interface,
@@ -932,7 +932,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         paramset_key: ParamsetKey | str,
         values: list[dict[str, Any]],
     ) -> None:
-        """Set paramset to CCU."""
+        """Set paramset to the backend."""
         params = {
             _JsonKey.INTERFACE: interface,
             _JsonKey.ADDRESS: address,
@@ -953,7 +953,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
             )
 
     async def get_value(self, interface: Interface, address: str, paramset_key: ParamsetKey, parameter: str) -> Any:
-        """Get value from CCU."""
+        """Get value from the backend."""
         value: Any = None
         params = {
             _JsonKey.INTERFACE: interface,
@@ -974,7 +974,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return value
 
     async def set_value(self, interface: Interface, address: str, parameter: str, value_type: str, value: Any) -> None:
-        """Set value to CCU."""
+        """Set value to the backend."""
         params = {
             _JsonKey.INTERFACE: interface,
             _JsonKey.ADDRESS: address,
@@ -998,7 +998,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
     async def get_paramset_description(
         self, interface: Interface, address: str, paramset_key: ParamsetKey
     ) -> Mapping[str, ParameterData] | None:
-        """Get paramset description from CCU."""
+        """Get paramset description from the backend."""
         paramset_description: dict[str, ParameterData] = {}
         params = {
             _JsonKey.INTERFACE: interface,
@@ -1119,7 +1119,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return tuple(all_programs)
 
     async def is_present(self, interface: Interface) -> bool:
-        """Get value from CCU."""
+        """Get value from the backend."""
         value: bool = False
         params = {_JsonKey.INTERFACE: interface}
 
@@ -1168,19 +1168,19 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return supported_methods
 
     async def _check_supported_methods(self) -> bool:
-        """Check, if all required api methods are supported by backend."""
+        """Check, if all required api methods are supported by the backend."""
         if self._supported_methods is None:
             self._supported_methods = await self._get_supported_methods()
         if unsupport_methods := tuple(method for method in _JsonRpcMethod if method not in self._supported_methods):
             _LOGGER.warning(
-                "CHECK_SUPPORTED_METHODS: methods not supported by backend: %s",
+                "CHECK_SUPPORTED_METHODS: methods not supported by the backend: %s",
                 ", ".join(unsupport_methods),
             )
             return False
         return True
 
     async def get_system_information(self) -> SystemInformation:
-        """Get system information of the backend."""
+        """Get system information of the the backend."""
 
         if (auth_enabled := await self._get_auth_enabled()) is not None and (
             system_information := SystemInformation(
@@ -1207,7 +1207,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return True
 
     async def list_devices(self, interface: Interface) -> tuple[DeviceDescription, ...]:
-        """List devices from CCU / Homegear."""
+        """List devices from the backend."""
         devices: tuple[DeviceDescription, ...] = ()
         _LOGGER.debug("LIST_DEVICES: Getting all available interfaces")
         params = {
@@ -1225,7 +1225,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return devices
 
     async def _list_interfaces(self) -> tuple[str, ...]:
-        """List all available interfaces from CCU / Homegear."""
+        """List all available interfaces from the backend."""
         _LOGGER.debug("LIST_INTERFACES: Getting all available interfaces")
 
         response = await self._post(

aiohomematic/client/xml_rpc.py

@@ -142,7 +142,7 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy, LogContextMixin):
         try:
             method = args[0]
             if self._supported_methods and method not in self._supported_methods:
-                raise UnsupportedException(f"__ASYNC_REQUEST: method '{method} not supported by backend.")
+                raise UnsupportedException(f"__ASYNC_REQUEST: method '{method} not supported by the backend.")
 
             if method in _VALID_XMLRPC_COMMANDS_ON_NO_CONNECTION or not self._connection_state.has_issue(
                 issuer=self, iid=self._interface_id

aiohomematic/const.py

@@ -19,7 +19,7 @@ import sys
 from types import MappingProxyType
 from typing import Any, Final, NamedTuple, Required, TypeAlias, TypedDict
 
-VERSION: Final = "2025.9.3"
+VERSION: Final = "2025.9.4"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (

aiohomematic/model/__init__.py

@@ -8,7 +8,7 @@ parameter descriptions into concrete data points and events:
 - generic: Default data point types (switch, number, sensor, select, etc.).
 - custom: Higher-level composites and device-specific behaviors.
 - calculated: Derived metrics (e.g., dew point, apparent temperature).
-- hub: Program and system variable data points from the backend hub (CCU/Homegear).
+- hub: Program and system variable data points from the backend hub.
 
 The create_data_points_and_events entrypoint inspects a device’s paramset
 information, applies visibility rules, creates events where appropriate, and

aiohomematic/model/calculated/data_point.py

@@ -32,7 +32,7 @@ from aiohomematic.model.support import (
     generate_unique_id,
     get_data_point_name_data,
 )
-from aiohomematic.property_decorators import cached_property, config_property, state_property
+from aiohomematic.property_decorators import config_property, hm_property, state_property
 
 _LOGGER: Final = logging.getLogger(__name__)
 
@@ -147,7 +147,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         """Return default value."""
         return self._default
 
-    @cached_property
+    @hm_property(cached=True)
     def dpk(self) -> DataPointKey:
         """Return data_point key value."""
         return DataPointKey(

aiohomematic/model/data_point.py

@@ -73,7 +73,7 @@ from aiohomematic.model.support import (
     convert_value,
     generate_unique_id,
 )
-from aiohomematic.property_decorators import cached_property, config_property, hm_property, state_property
+from aiohomematic.property_decorators import config_property, hm_property, state_property
 from aiohomematic.support import LogContextMixin, PayloadMixin, extract_exc_args, log_boundary_error
 
 __all__ = [
@@ -269,7 +269,7 @@ class CallbackDataPoint(ABC, LogContextMixin):
         """Return the data_point usage."""
         return DataPointUsage.DATA_POINT
 
-    @cached_property
+    @hm_property(cached=True)
     def enabled_default(self) -> bool:
         """Return, if data_point should be enabled based on usage attribute."""
         return self.usage in (
@@ -295,12 +295,12 @@ class CallbackDataPoint(ABC, LogContextMixin):
         return self._path_data.state_path
 
     # @property
-    @cached_property
+    @hm_property(cached=True)
     def service_methods(self) -> Mapping[str, Callable]:
         """Return all service methods."""
         return get_service_calls(obj=self)
 
-    @cached_property
+    @hm_property(cached=True)
     def service_method_names(self) -> tuple[str, ...]:
         """Return all service methods."""
         return tuple(self.service_methods.keys())
@@ -659,7 +659,7 @@ class BaseParameterDataPoint[
         """Return if the parameter is un ignored."""
         return self._is_un_ignored
 
-    @cached_property
+    @hm_property(cached=True)
     def dpk(self) -> DataPointKey:
         """Return data_point key value."""
         return DataPointKey(
@@ -699,7 +699,7 @@ class BaseParameterDataPoint[
         """Return raw unit value."""
         return self._raw_unit
 
-    @cached_property
+    @hm_property(cached=True)
     def requires_polling(self) -> bool:
         """Return whether the data_point requires polling."""
         return not self._channel.device.client.supports_push_updates or (
@@ -757,7 +757,7 @@ class BaseParameterDataPoint[
 
     @property
     def service(self) -> bool:
-        """Return the if data_point is visible in ccu."""
+        """Return the if data_point is visible in the backend."""
         return self._service
 
     @property
@@ -782,10 +782,10 @@ class BaseParameterDataPoint[
 
     @property
     def visible(self) -> bool:
-        """Return the if data_point is visible in ccu."""
+        """Return the if data_point is visible in the backend."""
         return self._visible
 
-    @cached_property
+    @hm_property(cached=True)
     def _enabled_by_channel_operation_mode(self) -> bool | None:
         """Return, if the data_point/event must be enabled."""
         if self._channel.type_name not in _CONFIGURABLE_CHANNEL:
@@ -1011,7 +1011,7 @@ class CallParameterCollector:
         )
 
     async def send_data(self, wait_for_callback: int | None) -> set[DP_KEY_VALUE]:
-        """Send data to backend."""
+        """Send data to the backend."""
         dpk_values: set[DP_KEY_VALUE] = set()
         for paramset_key, paramsets in self._paramsets.items():
             for _, paramset_no in sorted(paramsets.items()):

aiohomematic/model/device.py

@@ -80,7 +80,7 @@ from aiohomematic.model.support import (
     get_device_name,
 )
 from aiohomematic.model.update import DpUpdate
-from aiohomematic.property_decorators import cached_property, hm_property, info_property, state_property
+from aiohomematic.property_decorators import hm_property, info_property, state_property
 from aiohomematic.support import (
     CacheEntry,
     LogContextMixin,
@@ -371,7 +371,7 @@ class Device(LogContextMixin, PayloadMixin):
 
     @info_property
     def room(self) -> str | None:
-        """Return the room of the device, if only one assigned in CCU."""
+        """Return the room of the device, if only one assigned in the backend."""
         if self._rooms and len(self._rooms) == 1:
             return list(self._rooms)[0]
         if (maintenance_channel := self.get_channel(channel_address=f"{self._address}:0")) is not None:
@@ -441,7 +441,7 @@ class Device(LogContextMixin, PayloadMixin):
             for channel in self._channels.values():
                 await channel.remove_central_link()
 
-    @cached_property
+    @hm_property(cached=True)
     def relevant_for_central_link_management(self) -> bool:
         """Return if channel is relevant for central link management."""
         return (
@@ -860,7 +860,7 @@ class Channel(LogContextMixin, PayloadMixin):
 
     @info_property
     def room(self) -> str | None:
-        """Return the room of the device, if only one assigned in CCU."""
+        """Return the room of the device, if only one assigned in the backend."""
         if self._rooms and len(self._rooms) == 1:
             return list(self._rooms)[0]
         if self.is_group_master:
@@ -1190,7 +1190,7 @@ class _ValueCache:
             )
 
     async def _get_values_for_cache(self, dpk: DataPointKey) -> dict[str, Any]:
-        """Return a value from CCU to store in cache."""
+        """Return a value from the backend 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
@@ -1212,7 +1212,7 @@ class _ValueCache:
     def _add_entry_to_device_cache(self, dpk: DataPointKey, value: Any) -> None:
         """Add value to cache."""
         # write value to cache even if an exception has occurred
-        # to avoid repetitive calls to CCU within max_age
+        # to avoid repetitive calls to the backend within max_age
         self._device_cache[dpk] = CacheEntry(value=value, refresh_at=datetime.now())
 
     def _get_value_from_cache(

aiohomematic/model/generic/data_point.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2021-2025 Daniel Perna, SukramJ
-"""Generic python representation of a CCU parameter."""
+"""Generic python representation of a backend parameter."""
 
 from __future__ import annotations
 
@@ -21,7 +21,7 @@ from aiohomematic.decorators import inspector
 from aiohomematic.exceptions import ValidationException
 from aiohomematic.model import data_point as hme, device as hmd
 from aiohomematic.model.support import DataPointNameData, GenericParameterType, get_data_point_name_data
-from aiohomematic.property_decorators import cached_property
+from aiohomematic.property_decorators import hm_property
 
 _LOGGER: Final = logging.getLogger(__name__)
 
@@ -51,7 +51,7 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             parameter_data=parameter_data,
         )
 
-    @cached_property
+    @hm_property(cached=True)
     def usage(self) -> DataPointUsage:
         """Return the data_point usage."""
         if self._is_forced_sensor or self._is_un_ignored:

aiohomematic/model/hub/__init__.py

@@ -4,7 +4,7 @@
 Hub (backend) data points for AioHomematic.
 
 Overview
-- This module reflects the state and capabilities of the backend (CCU/Homegear)
+- This module reflects the state and capabilities of the backend
   at the hub level. It exposes backend programs and system variables as data
   points that can be observed and acted upon by higher layers (e.g.,
   integrations).
@@ -133,7 +133,7 @@ class ProgramDpType(NamedTuple):
 
 
 class Hub:
-    """The HomeMatic hub. (CCU/HomeGear)."""
+    """The HomeMatic hub."""
 
     __slots__ = (
         "_sema_fetch_sysvars",
@@ -223,7 +223,7 @@ class Hub:
             self._central.name,
         )
 
-        # remove some variables in case of CCU Backend
+        # remove some variables in case of CCU backend
         # - OldValue(s) are for internal calculations
         if self._central.model is Backend.CCU:
             variables = _clean_variables(variables)

aiohomematic/model/hub/data_point.py

@@ -216,7 +216,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
         self._reset_temporary_timestamps()
 
     def write_value(self, value: Any, write_at: datetime) -> None:
-        """Set variable value on CCU/Homegear."""
+        """Set variable value on the backend."""
         self._reset_temporary_value()
 
         old_value = self._current_value
@@ -262,7 +262,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
 
     @inspector
     async def send_variable(self, value: Any) -> None:
-        """Set variable value on CCU/Homegear."""
+        """Set variable value on the backend."""
         if client := self.central.primary_client:
             await client.set_system_variable(legacy_name=self._legacy_name, value=parse_sys_var(self._data_type, value))
         self._write_temporary_value(value=value, write_at=datetime.now())
@@ -316,7 +316,7 @@ class GenericProgramDataPoint(GenericHubDataPoint):
         return self._pid
 
     def update_data(self, data: ProgramData) -> None:
-        """Set variable value on CCU/Homegear."""
+        """Set variable value on the backend."""
         do_update: bool = False
         if self._is_active != data.is_active:
             self._is_active = data.is_active

aiohomematic/property_decorators.py

@@ -6,19 +6,16 @@ Decorators and helpers for declaring public attributes on data point classes.
 This module provides four decorator factories that behave like the built-in
 @property, but additionally annotate properties with a semantic category so they
 can be automatically collected to build payloads and log contexts:
-- cached_property: computed once per instance and cached until the value is
-  invalidated by a setter/deleter on the same descriptor.
 - config_property: configuration-related properties.
 - info_property: informational/metadata properties.
 - state_property: dynamic state properties.
+- hm_property: can be used to mark log_context or cached, where the other properties don't match
 
 All decorators accept an optional keyword-only argument log_context. If set to
 True, the property will be included in the LogContextMixin.log_context mapping.
 
 Notes on caching
-- cached_property always caches on first access and invalidates on set/delete.
-- The other decorators can be created with cached=True to enable the same
-  behavior when desired.
+- Marked with cached=True always caches on first access and invalidates on set/delete.
 """
 
 from __future__ import annotations
@@ -235,45 +232,6 @@ def hm_property[PR](
     return _GenericProperty(func, kind=kind, cached=cached, log_context=log_context)
 
 
-# ----- cached_property -----
-
-
-@overload
-def cached_property[PR](func: Callable[[Any], PR], /) -> _GenericProperty[PR, Any]: ...
-
-
-@overload
-def cached_property(*, log_context: bool = ...) -> Callable[[Callable[[Any], R]], _GenericProperty[R, Any]]: ...
-
-
-def cached_property[PR](
-    func: Callable[[Any], PR] | None = None,
-    *,
-    log_context: bool = False,
-) -> _GenericProperty[PR, Any] | Callable[[Callable[[Any], PR]], _GenericProperty[PR, Any]]:
-    """
-    Decorate a method as a computed attribute with per-instance caching.
-
-    Supports both usages:
-    - @cached_property
-    - @cached_property(log_context=True)
-
-    Args:
-        func: The function being decorated when used as @cached_property without
-            parentheses. When used as a factory (i.e., @cached_property(...)), this
-            is None and the returned callable expects the function to decorate.
-        log_context: Include this property in structured log context if True.
-
-    """
-    if func is None:
-
-        def wrapper(f: Callable[[Any], PR]) -> _GenericProperty[PR, Any]:
-            return _GenericProperty(f, kind=Kind.SIMPLE, cached=True, log_context=log_context)
-
-        return wrapper
-    return _GenericProperty(func, kind=Kind.SIMPLE, cached=True, log_context=log_context)
-
-
 # ----- config_property -----
 
 

aiohomematic/support.py

@@ -49,12 +49,7 @@ from aiohomematic.const import (
     SysvarType,
 )
 from aiohomematic.exceptions import AioHomematicException, BaseHomematicException
-from aiohomematic.property_decorators import (
-    Kind,
-    cached_property,
-    get_hm_property_by_kind,
-    get_hm_property_by_log_context,
-)
+from aiohomematic.property_decorators import Kind, get_hm_property_by_kind, get_hm_property_by_log_context, hm_property
 
 _LOGGER: Final = logging.getLogger(__name__)
 
@@ -585,7 +580,7 @@ class LogContextMixin:
 
     __slots__ = ("_cached_log_context",)
 
-    @cached_property
+    @hm_property(cached=True)
     def log_context(self) -> Mapping[str, Any]:
         """Return the log context for this object."""
         return {

{aiohomematic-2025.9.3.dist-info → aiohomematic-2025.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.9.3
+Version: 2025.9.4
 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>
@@ -53,7 +53,7 @@ Use the Home Assistant custom integration "Homematic(IP) Local", which is powere
 
 1. Prerequisites
    - Use latest version of Home Assistant.
-   - A CCU3, RaspberryMatic, or Homegear instance reachable from Home Assistant.
+   - A CCU3, OpenCCU/RaspberryMatic, or Homegear instance reachable from Home Assistant.
    - For HomematicIP devices, ensure CCU firmware meets the minimum versions listed below.
 2. Install the integration
    - Add the custom repository and install: https://github.com/sukramj/homematicip_local
@@ -77,7 +77,7 @@ Due to a bug in earlier CCU2/CCU3 firmware, aiohomematic requires at least the f
 - CCU2: 2.53.27
 - CCU3: 3.53.26
 
-See details here: https://github.com/jens-maus/RaspberryMatic/issues/843. Other CCU‑like platforms using the buggy HmIPServer version are not supported.
+See details here: https://github.com/OpenCCU/OpenCCU/issues/843. Other CCU‑like platforms using the buggy HmIPServer version are not supported.
 
 ## Public API and imports