aiohomematic 2025.10.0__py3-none-any.whl → 2025.10.2__py3-none-any.whl

aiohomematic/client/json_rpc.py

@@ -184,6 +184,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
     def __init__(
         self,
+        *,
         username: str,
         password: str,
         device_url: str,
@@ -204,7 +205,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         self._password: Final = password
         self._looper = Looper()
         self._tls: Final = tls
-        self._tls_context: Final[SSLContext | bool] = get_tls_context(verify_tls) if tls else False
+        self._tls_context: Final[SSLContext | bool] = get_tls_context(verify_tls=verify_tls) if tls else False
         self._url: Final = f"{device_url}{PATH_JSON_RPC}"
         self._script_cache: Final[dict[str, str]] = {}
         self._last_session_id_refresh: datetime | None = None
@@ -234,10 +235,10 @@ class JsonRpcAioHttpClient(LogContextMixin):
             self._last_session_id_refresh = datetime.now()
             return self._session_id is not None
         if self._session_id:
-            self._session_id = await self._do_renew_login(self._session_id)
+            self._session_id = await self._do_renew_login(session_id=self._session_id)
         return self._session_id is not None
 
-    async def _do_renew_login(self, session_id: str) -> str | None:
+    async def _do_renew_login(self, *, session_id: str) -> str | None:
         """Renew JSON-RPC session or perform login."""
         if self._has_session_recently_refreshed:
             return session_id
@@ -291,6 +292,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
     async def _post(
         self,
+        *,
         method: _JsonRpcMethod,
         extra_params: dict[_JsonKey, Any] | None = None,
         use_default_params: bool = True,
@@ -328,6 +330,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
     async def _post_script(
         self,
+        *,
         script_name: str,
         extra_params: dict[_JsonKey, Any] | None = None,
         keep_session: bool = True,
@@ -370,7 +373,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return response
 
-    async def _get_script(self, script_name: str) -> str | None:
+    async def _get_script(self, *, script_name: str) -> str | None:
         """Return a script from the script cache. Load if required."""
         if script_name in self._script_cache:
             return self._script_cache[script_name]
@@ -387,6 +390,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
     async def _do_post(
         self,
+        *,
         session_id: bool | str,
         method: _JsonRpcMethod,
         extra_params: dict[_JsonKey, Any] | None = None,
@@ -527,7 +531,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
             )
             raise ClientException(exc) from exc
 
-    async def _get_json_reponse(self, response: ClientResponse) -> dict[str, Any] | Any:
+    async def _get_json_reponse(self, *, response: ClientResponse) -> dict[str, Any] | Any:
         """Return the json object from response."""
         try:
             return await response.json(encoding=UTF_8)
@@ -543,7 +547,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         """Logout of the backend."""
         try:
             await self._looper.block_till_done()
-            await self._do_logout(self._session_id)
+            await self._do_logout(session_id=self._session_id)
         except BaseHomematicException:
             _LOGGER.debug("LOGOUT: logout failed")
 
@@ -552,7 +556,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         if self._is_internal_session:
             await self._client_session.close()
 
-    async def _do_logout(self, session_id: str | None) -> None:
+    async def _do_logout(self, *, session_id: str | None) -> None:
         """Logout of the backend."""
         if not session_id:
             _LOGGER.debug("DO_LOGOUT: Not logged in. Not logging out.")
@@ -579,7 +583,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         """Clear the current session."""
         self._session_id = None
 
-    async def execute_program(self, pid: str) -> bool:
+    async def execute_program(self, *, pid: str) -> bool:
         """Execute a program on the backend."""
         params = {
             _JsonKey.ID: pid,
@@ -596,7 +600,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return True
 
-    async def set_program_state(self, pid: str, state: bool) -> bool:
+    async def set_program_state(self, *, pid: str, state: bool) -> bool:
         """Set the program state on the backend."""
         params = {
             _JsonKey.ID: pid,
@@ -613,7 +617,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return True
 
-    async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
+    async def set_system_variable(self, *, legacy_name: str, value: Any) -> bool:
         """Set a system variable on the backend."""
         params = {_JsonKey.NAME: legacy_name, _JsonKey.VALUE: value}
         if isinstance(value, bool):
@@ -639,7 +643,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return True
 
-    async def delete_system_variable(self, name: str) -> bool:
+    async def delete_system_variable(self, *, name: str) -> bool:
         """Delete a system variable from the backend."""
         params = {_JsonKey.NAME: name}
         response = await self._post(
@@ -654,7 +658,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return True
 
-    async def get_system_variable(self, name: str) -> Any:
+    async def get_system_variable(self, *, name: str) -> Any:
         """Get single system variable from the backend."""
         params = {_JsonKey.NAME: name}
         response = await self._post(
@@ -666,7 +670,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return response[_JsonKey.RESULT]
 
     async def get_all_system_variables(
-        self, markers: tuple[DescriptionMarker | str, ...]
+        self, *, markers: tuple[DescriptionMarker | str, ...]
     ) -> tuple[SystemVariableData, ...]:
         """Get all system variables from the backend."""
         variables: list[SystemVariableData] = []
@@ -843,7 +847,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return channel_ids_function
 
-    async def get_device_description(self, interface: Interface, address: str) -> DeviceDescription | None:
+    async def get_device_description(self, *, interface: Interface, address: str) -> DeviceDescription | None:
         """Get device descriptions from the backend."""
         device_description: DeviceDescription | None = None
         params = {
@@ -860,7 +864,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return device_description
 
     @staticmethod
-    def _convert_device_description(json_data: dict[str, Any]) -> DeviceDescription:
+    def _convert_device_description(*, json_data: dict[str, Any]) -> DeviceDescription:
         """Convert json data dor device description."""
         device_description = DeviceDescription(
             TYPE=json_data["type"],
@@ -904,7 +908,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return device_details
 
     async def get_paramset(
-        self, interface: Interface, address: str, paramset_key: ParamsetKey | str
+        self, *, interface: Interface, address: str, paramset_key: ParamsetKey | str
     ) -> dict[str, Any] | None:
         """Get paramset from the backend."""
         paramset: dict[str, Any] = {}
@@ -927,6 +931,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
     async def put_paramset(
         self,
+        *,
         interface: Interface,
         address: str,
         paramset_key: ParamsetKey | str,
@@ -952,7 +957,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
                 str(json_result),
             )
 
-    async def get_value(self, interface: Interface, address: str, paramset_key: ParamsetKey, parameter: str) -> Any:
+    async def get_value(self, *, interface: Interface, address: str, paramset_key: ParamsetKey, parameter: str) -> Any:
         """Get value from the backend."""
         value: Any = None
         params = {
@@ -973,7 +978,9 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return value
 
-    async def set_value(self, interface: Interface, address: str, parameter: str, value_type: str, value: Any) -> None:
+    async def set_value(
+        self, *, interface: Interface, address: str, parameter: str, value_type: str, value: Any
+    ) -> None:
         """Set value to the backend."""
         params = {
             _JsonKey.INTERFACE: interface,
@@ -996,7 +1003,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
             )
 
     async def get_paramset_description(
-        self, interface: Interface, address: str, paramset_key: ParamsetKey
+        self, *, interface: Interface, address: str, paramset_key: ParamsetKey
     ) -> Mapping[str, ParameterData] | None:
         """Get paramset description from the backend."""
         paramset_description: dict[str, ParameterData] = {}
@@ -1015,7 +1022,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
         return paramset_description
 
     @staticmethod
-    def _convert_parameter_data(json_data: dict[str, Any]) -> ParameterData:
+    def _convert_parameter_data(*, json_data: dict[str, Any]) -> ParameterData:
         """Convert json data to parameter data."""
 
         _type = json_data["TYPE"]
@@ -1039,7 +1046,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return parameter_data
 
-    async def get_all_device_data(self, interface: Interface) -> Mapping[str, Any]:
+    async def get_all_device_data(self, *, interface: Interface) -> Mapping[str, Any]:
         """Get the all device data of the backend."""
         all_device_data: dict[str, Any] = {}
         params = {
@@ -1064,7 +1071,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return all_device_data
 
-    async def get_all_programs(self, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...]:
+    async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...]:
         """Get the all programs of the backend."""
         all_programs: list[ProgramData] = []
 
@@ -1118,7 +1125,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return tuple(all_programs)
 
-    async def is_present(self, interface: Interface) -> bool:
+    async def is_present(self, *, interface: Interface) -> bool:
         """Get value from the backend."""
         value: bool = False
         params = {_JsonKey.INTERFACE: interface}
@@ -1131,7 +1138,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return value
 
-    async def has_program_ids(self, channel_hmid: str) -> bool:
+    async def has_program_ids(self, *, channel_hmid: str) -> bool:
         """Return if a channel has program ids."""
         params = {_JsonKey.ID: channel_hmid}
         response = await self._post(
@@ -1206,7 +1213,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
         return True
 
-    async def list_devices(self, interface: Interface) -> tuple[DeviceDescription, ...]:
+    async def list_devices(self, *, interface: Interface) -> tuple[DeviceDescription, ...]:
         """List devices from the backend."""
         devices: tuple[DeviceDescription, ...] = ()
         _LOGGER.debug("LIST_DEVICES: Getting all available interfaces")
@@ -1262,6 +1269,7 @@ class JsonRpcAioHttpClient(LogContextMixin):
 
 
 def _get_params(
+    *,
     session_id: bool | str,
     extra_params: dict[_JsonKey, Any] | None,
     use_default_params: bool,

aiohomematic/client/xml_rpc.py

@@ -88,11 +88,14 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy):
 
     def __init__(
         self,
+        *,
         max_workers: int,
         interface_id: str,
         connection_state: hmcu.CentralConnectionState,
-        *args: Any,
-        **kwargs: Any,
+        uri: str,
+        headers: list[tuple[str, str]],
+        tls: bool = False,
+        verify_tls: bool = False,
     ) -> None:
         """Initialize new proxy for server and get local ip."""
         self._interface_id: Final = interface_id
@@ -101,17 +104,19 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy):
         self._proxy_executor: Final = (
             ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix=interface_id) if max_workers > 0 else None
         )
-        self._tls: Final[bool] = kwargs.pop(_TLS, False)
-        self._verify_tls: Final[bool] = kwargs.pop(_VERIFY_TLS, True)
+        self._tls: Final[bool] = tls
+        self._verify_tls: Final[bool] = verify_tls
         self._supported_methods: tuple[str, ...] = ()
+        kwargs: dict[str, Any] = {}
         if self._tls:
-            kwargs[_CONTEXT] = get_tls_context(self._verify_tls)
+            kwargs[_CONTEXT] = get_tls_context(verify_tls=self._verify_tls)
         # Due to magic method the log_context must be defined manually.
         self.log_context: Final[Mapping[str, Any]] = {"interface_id": self._interface_id, "tls": self._tls}
-        xmlrpc.client.ServerProxy.__init__(  # type: ignore[misc]
+        xmlrpc.client.ServerProxy.__init__(
             self,
+            uri=uri,
             encoding=ISO_8859_1,
-            *args,  # noqa: B026
+            headers=headers,
             **kwargs,
         )
 
@@ -234,7 +239,7 @@ def _cleanup_args(*args: Any) -> Any:
     return args
 
 
-def _cleanup_item(item: Any) -> Any:
+def _cleanup_item(*, item: Any) -> Any:
     """Cleanup a single item."""
     if isinstance(item, StrEnum):
         return str(item)
@@ -245,7 +250,7 @@ def _cleanup_item(item: Any) -> Any:
     return item
 
 
-def _cleanup_paramset(paramset: Mapping[str, Any]) -> Mapping[str, Any]:
+def _cleanup_paramset(*, paramset: Mapping[str, Any]) -> Mapping[str, Any]:
     """Cleanup a paramset."""
     new_paramset: dict[str, Any] = {}
     for name, value in paramset.items():

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.10.0"
+VERSION: Final = "2025.10.2"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -45,6 +45,7 @@ DEFAULT_SYSVAR_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
 DEFAULT_SYS_SCAN_INTERVAL: Final = 30
 DEFAULT_TLS: Final = False
 DEFAULT_UN_IGNORES: Final[frozenset[str]] = frozenset()
+DEFAULT_USE_GROUP_CHANNEL_FOR_COVER_STATE: Final = True
 DEFAULT_VERIFY_TLS: Final = False
 
 # Default encoding for json service calls, persistent cache
@@ -99,6 +100,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_CUSTOM_ID: Final = "custom_id"
 KWARGS_ARG_DATA_POINT: Final = "data_point"
 LAST_COMMAND_SEND_STORE_TIMEOUT: Final = 60
 LOCAL_HOST: Final = "127.0.0.1"

aiohomematic/converter.py

@@ -21,23 +21,23 @@ _LOGGER = logging.getLogger(__name__)
 
 
 @lru_cache(maxsize=1024)
-def _convert_cpv_to_hm_level(cpv: Any) -> Any:
+def _convert_cpv_to_hm_level(*, value: Any) -> Any:
     """Convert combined parameter value for hm level."""
-    if isinstance(cpv, str) and cpv.startswith("0x"):
-        return ast.literal_eval(cpv) / 100 / 2
-    return cpv
+    if isinstance(value, str) and value.startswith("0x"):
+        return ast.literal_eval(value) / 100 / 2
+    return value
 
 
 @lru_cache(maxsize=1024)
-def _convert_cpv_to_hmip_level(cpv: Any) -> Any:
+def _convert_cpv_to_hmip_level(*, value: Any) -> Any:
     """Convert combined parameter value for hmip level."""
-    return int(cpv) / 100
+    return int(value) / 100
 
 
 @lru_cache(maxsize=1024)
-def convert_hm_level_to_cpv(hm_level: Any) -> Any:
+def convert_hm_level_to_cpv(*, value: Any) -> Any:
     """Convert hm level to combined parameter value."""
-    return format(int(hm_level * 100 * 2), "#04x")
+    return format(int(value * 100 * 2), "#04x")
 
 
 CONVERTABLE_PARAMETERS: Final = (Parameter.COMBINED_PARAMETER, Parameter.LEVEL_COMBINED)
@@ -52,28 +52,28 @@ _COMBINED_PARAMETER_NAMES: Final = {"L": Parameter.LEVEL, "L2": Parameter.LEVEL_
 
 
 @lru_cache(maxsize=1024)
-def _convert_combined_parameter_to_paramset(cpv: str) -> dict[str, Any]:
+def _convert_combined_parameter_to_paramset(*, value: str) -> dict[str, Any]:
     """Convert combined parameter to paramset."""
     paramset: dict[str, Any] = {}
-    for cp_param_value in cpv.split(","):
+    for cp_param_value in value.split(","):
         cp_param, value = cp_param_value.split("=")
         if parameter := _COMBINED_PARAMETER_NAMES.get(cp_param):
             if converter := _COMBINED_PARAMETER_TO_HM_CONVERTER.get(parameter):
-                paramset[parameter] = converter(value)
+                paramset[parameter] = converter(value=value)
             else:
                 paramset[parameter] = value
     return paramset
 
 
 @lru_cache(maxsize=1024)
-def _convert_level_combined_to_paramset(lcv: str) -> dict[str, Any]:
+def _convert_level_combined_to_paramset(*, value: str) -> dict[str, Any]:
     """Convert combined parameter to paramset."""
-    if "," in lcv:
-        l1_value, l2_value = lcv.split(",")
+    if "," in value:
+        l1_value, l2_value = value.split(",")
         if converter := _COMBINED_PARAMETER_TO_HM_CONVERTER.get(Parameter.LEVEL_COMBINED):
             return {
-                Parameter.LEVEL: converter(l1_value),
-                Parameter.LEVEL_SLATS: converter(l2_value),
+                Parameter.LEVEL: converter(value=l1_value),
+                Parameter.LEVEL_SLATS: converter(value=l2_value),
             }
     return {}
 
@@ -85,12 +85,12 @@ _COMBINED_PARAMETER_TO_PARAMSET_CONVERTER: Final = {
 
 
 @lru_cache(maxsize=1024)
-def convert_combined_parameter_to_paramset(parameter: str, cpv: str) -> dict[str, Any]:
+def convert_combined_parameter_to_paramset(*, parameter: str, value: str) -> dict[str, Any]:
     """Convert combined parameter to paramset."""
     try:
         if converter := _COMBINED_PARAMETER_TO_PARAMSET_CONVERTER.get(parameter):  # type: ignore[call-overload]
-            return cast(dict[str, Any], converter(cpv))
-        _LOGGER.debug("CONVERT_COMBINED_PARAMETER_TO_PARAMSET: No converter found for %s: %s", parameter, cpv)
+            return cast(dict[str, Any], converter(value=value))
+        _LOGGER.debug("CONVERT_COMBINED_PARAMETER_TO_PARAMSET: No converter found for %s: %s", parameter, value)
     except Exception as exc:
         _LOGGER.debug("CONVERT_COMBINED_PARAMETER_TO_PARAMSET: Convert failed %s", extract_exc_args(exc=exc))
     return {}

aiohomematic/exceptions.py

@@ -102,12 +102,13 @@ class InternalBackendException(BaseHomematicException):
         super().__init__("InternalBackendException", *args)
 
 
-def _reduce_args(args: tuple[Any, ...]) -> tuple[Any, ...] | Any:
+def _reduce_args(*, args: tuple[Any, ...]) -> tuple[Any, ...] | Any:
     """Return the first arg, if there is only one arg."""
     return args[0] if len(args) == 1 else args
 
 
 def log_exception[**P, R](
+    *,
     exc_type: type[BaseException],
     logger: logging.Logger = _LOGGER,
     level: int = logging.ERROR,

aiohomematic/model/__init__.py

@@ -46,7 +46,7 @@ _LOGGER: Final = logging.getLogger(__name__)
 
 
 @inspector
-def create_data_points_and_events(device: hmd.Device) -> None:
+def create_data_points_and_events(*, device: hmd.Device) -> None:
     """Create the data points associated to this device."""
     for channel in device.channels.values():
         for paramset_key, paramsset_key_descriptions in channel.paramset_descriptions.items():
@@ -83,6 +83,7 @@ def create_data_points_and_events(device: hmd.Device) -> None:
 
 
 def _process_parameter(
+    *,
     channel: hmd.Channel,
     paramset_key: ParamsetKey,
     parameter: str,
@@ -119,7 +120,7 @@ def _process_parameter(
         )
 
 
-def _should_create_event(parameter_data: ParameterData, parameter: str) -> bool:
+def _should_create_event(*, parameter_data: ParameterData, parameter: str) -> bool:
     """Determine if an event should be created for the parameter."""
     return bool(
         parameter_data["OPERATIONS"] & Operations.EVENT
@@ -127,7 +128,7 @@ def _should_create_event(parameter_data: ParameterData, parameter: str) -> bool:
     )
 
 
-def _should_skip_data_point(parameter_data: ParameterData, parameter: str, parameter_is_un_ignored: bool) -> bool:
+def _should_skip_data_point(*, parameter_data: ParameterData, parameter: str, parameter_is_un_ignored: bool) -> bool:
     """Determine if a data point should be skipped."""
     return bool(
         (not parameter_data["OPERATIONS"] & Operations.EVENT and not parameter_data["OPERATIONS"] & Operations.WRITE)

aiohomematic/model/calculated/__init__.py

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

aiohomematic/model/calculated/climate.py

@@ -34,7 +34,7 @@ class BaseClimateSensor[SensorT: float | None](CalculatedDataPoint[SensorT]):
 
     _category = DataPointCategory.SENSOR
 
-    def __init__(self, channel: hmd.Channel) -> None:
+    def __init__(self, *, channel: hmd.Channel) -> None:
         """Initialize the data point."""
 
         super().__init__(channel=channel)
@@ -70,7 +70,7 @@ class ApparentTemperature(BaseClimateSensor):
 
     _calculated_parameter = CalulatedParameter.APPARENT_TEMPERATURE
 
-    def __init__(self, channel: hmd.Channel) -> None:
+    def __init__(self, *, channel: hmd.Channel) -> None:
         """Initialize the data point."""
         super().__init__(channel=channel)
         self._unit = "°C"
@@ -83,7 +83,7 @@ class ApparentTemperature(BaseClimateSensor):
         )
 
     @staticmethod
-    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+    def is_relevant_for_model(*, channel: hmd.Channel) -> bool:
         """Return if this calculated data point is relevant for the model."""
         return (
             element_matches_key(
@@ -120,13 +120,13 @@ class DewPoint(BaseClimateSensor):
 
     _calculated_parameter = CalulatedParameter.DEW_POINT
 
-    def __init__(self, channel: hmd.Channel) -> None:
+    def __init__(self, *, channel: hmd.Channel) -> None:
         """Initialize the data point."""
         super().__init__(channel=channel)
         self._unit = "°C"
 
     @staticmethod
-    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+    def is_relevant_for_model(*, channel: hmd.Channel) -> bool:
         """Return if this calculated data point is relevant for the model."""
         return _is_relevant_for_model_temperature_and_humidity(channel=channel)
 
@@ -148,13 +148,13 @@ class FrostPoint(BaseClimateSensor):
 
     _calculated_parameter = CalulatedParameter.FROST_POINT
 
-    def __init__(self, channel: hmd.Channel) -> None:
+    def __init__(self, *, channel: hmd.Channel) -> None:
         """Initialize the data point."""
         super().__init__(channel=channel)
         self._unit = "°C"
 
     @staticmethod
-    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+    def is_relevant_for_model(*, channel: hmd.Channel) -> bool:
         """Return if this calculated data point is relevant for the model."""
         return _is_relevant_for_model_temperature_and_humidity(
             channel=channel, relevant_models=_RELEVANT_MODELS_FROST_POINT
@@ -178,13 +178,13 @@ class VaporConcentration(BaseClimateSensor):
 
     _calculated_parameter = CalulatedParameter.VAPOR_CONCENTRATION
 
-    def __init__(self, channel: hmd.Channel) -> None:
+    def __init__(self, *, channel: hmd.Channel) -> None:
         """Initialize the data point."""
         super().__init__(channel=channel)
         self._unit = "g/m³"
 
     @staticmethod
-    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+    def is_relevant_for_model(*, channel: hmd.Channel) -> bool:
         """Return if this calculated data point is relevant for the model."""
         return _is_relevant_for_model_temperature_and_humidity(channel=channel)
 

aiohomematic/model/calculated/data_point.py

@@ -59,6 +59,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
 
     def __init__(
         self,
+        *,
         channel: hmd.Channel,
     ) -> None:
         """Initialize the data point."""
@@ -92,7 +93,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         )
 
     def _add_data_point[DataPointT: hmge.GenericDataPoint](
-        self, parameter: str, paramset_key: ParamsetKey | None, data_point_type: type[DataPointT]
+        self, *, parameter: str, paramset_key: ParamsetKey | None, data_point_type: type[DataPointT]
     ) -> DataPointT:
         """Add a new data point."""
         if generic_data_point := self._channel.get_generic_data_point(parameter=parameter, paramset_key=paramset_key):
@@ -109,7 +110,12 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         )
 
     def _add_device_data_point[DataPointT: hmge.GenericDataPoint](
-        self, channel_address: str, parameter: str, paramset_key: ParamsetKey | None, data_point_type: type[DataPointT]
+        self,
+        *,
+        channel_address: str,
+        parameter: str,
+        paramset_key: ParamsetKey | None,
+        data_point_type: type[DataPointT],
     ) -> DataPointT:
         """Add a new data point."""
         if generic_data_point := self._channel.device.get_generic_data_point(
@@ -133,7 +139,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         return bool(self._operations & Operations.READ)
 
     @staticmethod
-    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+    def is_relevant_for_model(*, channel: hmd.Channel) -> bool:
         """Return if this calculated data point is relevant for the channel."""
         return False
 
@@ -286,7 +292,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         """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:
+    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:
             await dp.load_data_point_value(call_source=call_source, direct_call=direct_call)
@@ -306,7 +312,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_event_recently:  # pylint: disable=using-constant-test
             return False
 
         if (relevant_values_data_point := self._relevant_values_data_points) is not None and len(
@@ -314,9 +320,9 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         ) <= 1:
             return True
 
-        return all(dp.fired_recently for dp in relevant_values_data_point)
+        return all(dp.fired_event_recently for dp in relevant_values_data_point)
 
-    def _unregister_data_point_updated_callback(self, cb: Callable, custom_id: str) -> None:
+    def _unregister_data_point_updated_callback(self, *, cb: Callable, custom_id: str) -> None:
         """Unregister update callback."""
         for unregister in self._unregister_callbacks:
             if unregister is not None:

aiohomematic/model/calculated/operating_voltage_level.py

@@ -41,7 +41,7 @@ class OperatingVoltageLevel[SensorT: float | None](CalculatedDataPoint[SensorT])
     _calculated_parameter = CalulatedParameter.OPERATING_VOLTAGE_LEVEL
     _category = DataPointCategory.SENSOR
 
-    def __init__(self, channel: hmd.Channel) -> None:
+    def __init__(self, *, channel: hmd.Channel) -> None:
         """Initialize the data point."""
         super().__init__(channel=channel)
         self._type = ParameterType.FLOAT
@@ -89,7 +89,7 @@ class OperatingVoltageLevel[SensorT: float | None](CalculatedDataPoint[SensorT])
         )
 
     @staticmethod
-    def is_relevant_for_model(channel: hmd.Channel) -> bool:
+    def is_relevant_for_model(*, channel: hmd.Channel) -> bool:
         """Return if this calculated data point is relevant for the model."""
         if element_matches_key(
             search_elements=_IGNORE_OPERATING_VOLTAGE_LEVEL_MODELS, compare_with=channel.device.model