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

aiohomematic/client/json_rpc.py

@@ -91,7 +91,7 @@ from aiohomematic.exceptions import (
     UnsupportedException,
 )
 from aiohomematic.model.support import convert_value
-from aiohomematic.property_decorators import info_property
+from aiohomematic.property_decorators import hm_property
 from aiohomematic.support import (
     LogContextMixin,
     cleanup_text_from_html_tags,
@@ -217,12 +217,12 @@ class JsonRpcAioHttpClient(LogContextMixin):
         """If session exists, then it is activated."""
         return self._session_id is not None
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def url(self) -> str | None:
         """Return url."""
         return self._url
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def tls(self) -> bool:
         """Return tls."""
         return self._tls
@@ -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

@@ -42,7 +42,7 @@ from aiohomematic.exceptions import (
     NoConnectionException,
     UnsupportedException,
 )
-from aiohomematic.property_decorators import info_property
+from aiohomematic.property_decorators import hm_property
 from aiohomematic.support import LogContextMixin, extract_exc_args, get_tls_context, log_boundary_error
 
 _LOGGER: Final = logging.getLogger(__name__)
@@ -121,7 +121,7 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy, LogContextMixin):
             supported_methods.append(_XmlRpcMethod.PING)
             self._supported_methods = tuple(supported_methods)
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def interface_id(self) -> str:
         """Return the interface_id."""
         return self._interface_id
@@ -131,7 +131,7 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy, LogContextMixin):
         """Return the supported methods."""
         return self._supported_methods
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def tls(self) -> bool:
         """Return tls."""
         return self._tls
@@ -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.2"
+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_slot_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_slot_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_slot_property, config_property, info_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_slot_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_slot_property
+    @hm_property(cached=True)
     def service_methods(self) -> Mapping[str, Callable]:
         """Return all service methods."""
         return get_service_calls(obj=self)
 
-    @cached_slot_property
+    @hm_property(cached=True)
     def service_method_names(self) -> tuple[str, ...]:
         """Return all service methods."""
         return tuple(self.service_methods.keys())
@@ -447,7 +447,7 @@ class BaseDataPoint(CallbackDataPoint, PayloadMixin):
         """Return the availability of the device."""
         return self._device.available
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def channel(self) -> hmd.Channel:
         """Return the channel the data_point."""
         return self._channel
@@ -659,7 +659,7 @@ class BaseParameterDataPoint[
         """Return if the parameter is un ignored."""
         return self._is_un_ignored
 
-    @cached_slot_property
+    @hm_property(cached=True)
     def dpk(self) -> DataPointKey:
         """Return data_point key value."""
         return DataPointKey(
@@ -684,7 +684,7 @@ class BaseParameterDataPoint[
         """Return multiplier value."""
         return self._multiplier
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def parameter(self) -> str:
         """Return parameter name."""
         return self._parameter
@@ -699,7 +699,7 @@ class BaseParameterDataPoint[
         """Return raw unit value."""
         return self._raw_unit
 
-    @cached_slot_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_slot_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_slot_property, info_property, state_property
+from aiohomematic.property_decorators import hm_property, info_property, state_property
 from aiohomematic.support import (
     CacheEntry,
     LogContextMixin,
@@ -327,7 +327,7 @@ class Device(LogContextMixin, PayloadMixin):
         """Return the interface of the device."""
         return self._interface
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def interface_id(self) -> str:
         """Return the interface_id of the device."""
         return self._interface_id
@@ -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_slot_property
+    @hm_property(cached=True)
     def relevant_for_central_link_management(self) -> bool:
         """Return if channel is relevant for central link management."""
         return (
@@ -762,7 +762,7 @@ class Channel(LogContextMixin, PayloadMixin):
         """Return the device description for the channel."""
         return self._description
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def device(self) -> Device:
         """Return the device of the channel."""
         return self._device
@@ -832,7 +832,7 @@ class Channel(LogContextMixin, PayloadMixin):
         """Return the name data of the channel."""
         return self._name_data
 
-    @info_property(log_context=True)
+    @hm_property(log_context=True)
     def no(self) -> int | None:
         """Return the channel_no of the channel."""
         return self._no
@@ -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_slot_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_slot_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