aiohomematic 2025.10.1__py3-none-any.whl → 2025.10.3__py3-none-any.whl

aiohomematic/model/hub/__init__.py

@@ -142,7 +142,7 @@ class Hub:
         "_config",
     )
 
-    def __init__(self, central: hmcu.CentralUnit) -> None:
+    def __init__(self, *, central: hmcu.CentralUnit) -> None:
         """Initialize Homematic hub."""
         self._sema_fetch_sysvars: Final = asyncio.Semaphore()
         self._sema_fetch_programs: Final = asyncio.Semaphore()
@@ -150,7 +150,7 @@ class Hub:
         self._config: Final = central.config
 
     @inspector(re_raise=False)
-    async def fetch_sysvar_data(self, scheduled: bool) -> None:
+    async def fetch_sysvar_data(self, *, scheduled: bool) -> None:
         """Fetch sysvar data for the hub."""
         if self._config.enable_sysvar_scan:
             _LOGGER.debug(
@@ -163,7 +163,7 @@ class Hub:
                     await self._update_sysvar_data_points()
 
     @inspector(re_raise=False)
-    async def fetch_program_data(self, scheduled: bool) -> None:
+    async def fetch_program_data(self, *, scheduled: bool) -> None:
         """Fetch program data for the hub."""
         if self._config.enable_program_scan:
             _LOGGER.debug(
@@ -206,7 +206,7 @@ class Hub:
         if new_programs:
             self._central.fire_backend_system_callback(
                 system_event=BackendSystemEvent.HUB_REFRESHED,
-                new_hub_data_points=_get_new_hub_data_points(data_points=new_programs),
+                new_data_points=_get_new_hub_data_points(data_points=new_programs),
             )
 
     async def _update_sysvar_data_points(self) -> None:
@@ -226,7 +226,7 @@ class Hub:
         # 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)
+            variables = _clean_variables(variables=variables)
 
         if missing_variable_ids := self._identify_missing_variable_ids(variables=variables):
             self._remove_sysvar_data_point(del_data_point_ids=missing_variable_ids)
@@ -242,10 +242,10 @@ class Hub:
         if new_sysvars:
             self._central.fire_backend_system_callback(
                 system_event=BackendSystemEvent.HUB_REFRESHED,
-                new_hub_data_points=_get_new_hub_data_points(data_points=new_sysvars),
+                new_data_points=_get_new_hub_data_points(data_points=new_sysvars),
             )
 
-    def _create_program_dp(self, data: ProgramData) -> ProgramDpType:
+    def _create_program_dp(self, *, data: ProgramData) -> ProgramDpType:
         """Create program as data_point."""
         program_dp = ProgramDpType(
             pid=data.pid,
@@ -255,13 +255,13 @@ class Hub:
         self._central.add_program_data_point(program_dp=program_dp)
         return program_dp
 
-    def _create_system_variable(self, data: SystemVariableData) -> GenericSysvarDataPoint:
+    def _create_system_variable(self, *, data: SystemVariableData) -> GenericSysvarDataPoint:
         """Create system variable as data_point."""
         sysvar_dp = self._create_sysvar_data_point(data=data)
         self._central.add_sysvar_data_point(sysvar_data_point=sysvar_dp)
         return sysvar_dp
 
-    def _create_sysvar_data_point(self, data: SystemVariableData) -> GenericSysvarDataPoint:
+    def _create_sysvar_data_point(self, *, data: SystemVariableData) -> GenericSysvarDataPoint:
         """Create sysvar data_point."""
         data_type = data.data_type
         extended_sysvar = data.extended_sysvar
@@ -279,21 +279,21 @@ class Hub:
 
         return SysvarDpSensor(central=self._central, data=data)
 
-    def _remove_program_data_point(self, ids: set[str]) -> None:
+    def _remove_program_data_point(self, *, ids: set[str]) -> None:
         """Remove sysvar data_point from hub."""
         for pid in ids:
             self._central.remove_program_button(pid=pid)
 
-    def _remove_sysvar_data_point(self, del_data_point_ids: set[str]) -> None:
+    def _remove_sysvar_data_point(self, *, del_data_point_ids: set[str]) -> None:
         """Remove sysvar data_point from hub."""
         for vid in del_data_point_ids:
             self._central.remove_sysvar_data_point(vid=vid)
 
-    def _identify_missing_program_ids(self, programs: tuple[ProgramData, ...]) -> set[str]:
+    def _identify_missing_program_ids(self, *, programs: tuple[ProgramData, ...]) -> set[str]:
         """Identify missing programs."""
         return {dp.pid for dp in self._central.program_data_points if dp.pid not in [x.pid for x in programs]}
 
-    def _identify_missing_variable_ids(self, variables: tuple[SystemVariableData, ...]) -> set[str]:
+    def _identify_missing_variable_ids(self, *, variables: tuple[SystemVariableData, ...]) -> set[str]:
         """Identify missing variables."""
         variable_ids: dict[str, bool] = {x.vid: x.extended_sysvar for x in variables}
         missing_variable_ids: list[str] = []
@@ -307,17 +307,18 @@ class Hub:
         return set(missing_variable_ids)
 
 
-def _is_excluded(variable: str, excludes: list[str]) -> bool:
+def _is_excluded(*, variable: str, excludes: list[str]) -> bool:
     """Check if variable is excluded by exclude_list."""
     return any(marker in variable for marker in excludes)
 
 
-def _clean_variables(variables: tuple[SystemVariableData, ...]) -> tuple[SystemVariableData, ...]:
+def _clean_variables(*, variables: tuple[SystemVariableData, ...]) -> tuple[SystemVariableData, ...]:
     """Clean variables by removing excluded."""
-    return tuple(sv for sv in variables if not _is_excluded(sv.legacy_name, _EXCLUDED))
+    return tuple(sv for sv in variables if not _is_excluded(variable=sv.legacy_name, excludes=_EXCLUDED))
 
 
 def _get_new_hub_data_points(
+    *,
     data_points: Collection[GenericHubDataPoint],
 ) -> Mapping[DataPointCategory, AbstractSet[GenericHubDataPoint]]:
     """Return data points as category dict."""

aiohomematic/model/hub/data_point.py

@@ -47,6 +47,7 @@ class GenericHubDataPoint(CallbackDataPoint, PayloadMixin):
 
     def __init__(
         self,
+        *,
         central: hmcu.CentralUnit,
         address: str,
         data: HubData,
@@ -132,6 +133,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
 
     def __init__(
         self,
+        *,
         central: hmcu.CentralUnit,
         data: SystemVariableData,
     ) -> None:
@@ -206,7 +208,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
         """Return the path data of the data_point."""
         return SysvarPathData(vid=self._vid)
 
-    async def event(self, value: Any, received_at: datetime) -> None:
+    async def event(self, *, value: Any, received_at: datetime) -> None:
         """Handle event for which this data_point has subscribed."""
         self.write_value(value=value, write_at=received_at)
 
@@ -215,7 +217,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
         self._temporary_value = None
         self._reset_temporary_timestamps()
 
-    def write_value(self, value: Any, write_at: datetime) -> None:
+    def write_value(self, *, value: Any, write_at: datetime) -> None:
         """Set variable value on the backend."""
         self._reset_temporary_value()
 
@@ -230,7 +232,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
         self._state_uncertain = False
         self.fire_data_point_updated_callback()
 
-    def _write_temporary_value(self, value: Any, write_at: datetime) -> None:
+    def _write_temporary_value(self, *, value: Any, write_at: datetime) -> None:
         """Update the temporary value of the data_point."""
         self._reset_temporary_value()
 
@@ -243,7 +245,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
             self._state_uncertain = True
         self.fire_data_point_updated_callback()
 
-    def _convert_value(self, old_value: Any, new_value: Any) -> Any:
+    def _convert_value(self, *, old_value: Any, new_value: Any) -> Any:
         """Convert to value to SYSVAR_TYPE."""
         if new_value is None:
             return None
@@ -261,10 +263,12 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
         return value
 
     @inspector
-    async def send_variable(self, value: Any) -> None:
+    async def send_variable(self, *, value: Any) -> None:
         """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))
+            await client.set_system_variable(
+                legacy_name=self._legacy_name, value=parse_sys_var(data_type=self._data_type, raw_value=value)
+            )
         self._write_temporary_value(value=value, write_at=datetime.now())
 
 
@@ -280,6 +284,7 @@ class GenericProgramDataPoint(GenericHubDataPoint):
 
     def __init__(
         self,
+        *,
         central: hmcu.CentralUnit,
         data: ProgramData,
     ) -> None:
@@ -315,7 +320,7 @@ class GenericProgramDataPoint(GenericHubDataPoint):
         """Return the program id."""
         return self._pid
 
-    def update_data(self, data: ProgramData) -> None:
+    def update_data(self, *, data: ProgramData) -> None:
         """Set variable value on the backend."""
         do_update: bool = False
         if self._is_active != data.is_active:

aiohomematic/model/hub/number.py

@@ -23,11 +23,11 @@ class SysvarDpNumber(GenericSysvarDataPoint):
     _is_extended = True
 
     @inspector
-    async def send_variable(self, value: float) -> None:
+    async def send_variable(self, *, value: float) -> None:
         """Set the value of the data_point."""
         if value is not None and self.max is not None and self.min is not None:
             if self.min <= float(value) <= self.max:
-                await super().send_variable(value)
+                await super().send_variable(value=value)
             else:
                 _LOGGER.warning(
                     "SYSVAR.NUMBER failed: Invalid value: %s (min: %s, max: %s)",
@@ -36,4 +36,4 @@ class SysvarDpNumber(GenericSysvarDataPoint):
                     self.max,
                 )
             return
-        await super().send_variable(value)
+        await super().send_variable(value=value)

aiohomematic/model/hub/select.py

@@ -32,15 +32,15 @@ class SysvarDpSelect(GenericSysvarDataPoint):
         return None
 
     @inspector
-    async def send_variable(self, value: int | str) -> None:
+    async def send_variable(self, *, value: int | str) -> None:
         """Set the value of the data_point."""
         # We allow setting the value via index as well, just in case.
         if isinstance(value, int) and self._values:
             if 0 <= value < len(self._values):
-                await super().send_variable(value)
+                await super().send_variable(value=value)
         elif self._values:
             if value in self._values:
-                await super().send_variable(self._values.index(value))
+                await super().send_variable(value=self._values.index(value))
         else:
             _LOGGER.warning(
                 "Value not in value_list for %s/%s",

aiohomematic/model/hub/text.py

@@ -25,6 +25,6 @@ class SysvarDpText(GenericSysvarDataPoint):
         """Get the value of the data_point."""
         return cast(str | None, check_length_and_log(name=self._legacy_name, value=self._value))
 
-    async def send_variable(self, value: str | None) -> None:
+    async def send_variable(self, *, value: str | None) -> None:
         """Set the value of the data_point."""
-        await super().send_variable(value)
+        await super().send_variable(value=value)

aiohomematic/model/support.py

@@ -74,7 +74,7 @@ class ChannelNameData:
         "sub_device_name",
     )
 
-    def __init__(self, device_name: str, channel_name: str) -> None:
+    def __init__(self, *, device_name: str, channel_name: str) -> None:
         """Init the DataPointNameData class."""
         self.device_name: Final = device_name
         self.channel_name: Final = self._get_channel_name(device_name=device_name, channel_name=channel_name)
@@ -87,7 +87,7 @@ class ChannelNameData:
         return ChannelNameData(device_name="", channel_name="")
 
     @staticmethod
-    def _get_channel_name(device_name: str, channel_name: str) -> str:
+    def _get_channel_name(*, device_name: str, channel_name: str) -> str:
         """Return the channel_name of the data_point only name."""
         if device_name and channel_name and channel_name.startswith(device_name):
             c_name = channel_name.replace(device_name, "").strip()
@@ -105,7 +105,7 @@ class DataPointNameData(ChannelNameData):
         "parameter_name",
     )
 
-    def __init__(self, device_name: str, channel_name: str, parameter_name: str | None = None) -> None:
+    def __init__(self, *, device_name: str, channel_name: str, parameter_name: str | None = None) -> None:
         """Init the DataPointNameData class."""
         super().__init__(device_name=device_name, channel_name=channel_name)
 
@@ -121,13 +121,13 @@ class DataPointNameData(ChannelNameData):
         return DataPointNameData(device_name="", channel_name="")
 
     @staticmethod
-    def _get_channel_parameter_name(channel_name: str, parameter_name: str | None) -> str:
+    def _get_channel_parameter_name(*, channel_name: str, parameter_name: str | None) -> str:
         """Return the channel parameter name of the data_point."""
         if channel_name and parameter_name:
             return f"{channel_name} {parameter_name}".strip()
         return channel_name.strip()
 
-    def _get_data_point_name(self, device_name: str, channel_name: str, parameter_name: str | None) -> str:
+    def _get_data_point_name(self, *, device_name: str, channel_name: str, parameter_name: str | None) -> str:
         """Return the name of the data_point only name."""
         channel_parameter_name = self._get_channel_parameter_name(
             channel_name=channel_name, parameter_name=parameter_name
@@ -145,7 +145,7 @@ class HubNameData:
         "name",
     )
 
-    def __init__(self, name: str, central_name: str | None = None, channel_name: str | None = None) -> None:
+    def __init__(self, *, name: str, central_name: str | None = None, channel_name: str | None = None) -> None:
         """Init the DataPointNameData class."""
         self.name: Final = name
         self.full_name = (
@@ -227,6 +227,7 @@ class DataPointPathData(PathData):
 
     def __init__(
         self,
+        *,
         interface: Interface | None,
         address: str,
         channel_no: int | None,
@@ -261,7 +262,7 @@ class ProgramPathData(PathData):
         "_state_path",
     )
 
-    def __init__(self, pid: str):
+    def __init__(self, *, pid: str):
         """Init the path data."""
         self._set_path: Final = f"{PROGRAM_SET_PATH_ROOT}/{pid}"
         self._state_path: Final = f"{PROGRAM_STATE_PATH_ROOT}/{pid}"
@@ -285,7 +286,7 @@ class SysvarPathData(PathData):
         "_state_path",
     )
 
-    def __init__(self, vid: str):
+    def __init__(self, *, vid: str):
         """Init the path data."""
         self._set_path: Final = f"{SYSVAR_SET_PATH_ROOT}/{vid}"
         self._state_path: Final = f"{SYSVAR_STATE_PATH_ROOT}/{vid}"
@@ -527,7 +528,7 @@ def _convert_value_noncached(value: Any, target_type: ParameterType, value_list:
             # relevant for ENUMs retyped to a BOOL
             return _get_binary_sensor_value(value=value, value_list=value_list)
         if isinstance(value, str):
-            return to_bool(value)
+            return to_bool(value=value)
         return bool(value)
     if target_type == ParameterType.FLOAT:
         return float(value)

aiohomematic/model/update.py

@@ -39,7 +39,7 @@ class DpUpdate(CallbackDataPoint, PayloadMixin):
 
     _category = DataPointCategory.UPDATE
 
-    def __init__(self, device: hmd.Device) -> None:
+    def __init__(self, *, device: hmd.Device) -> None:
         """Init the callback data_point."""
         PayloadMixin.__init__(self)
         self._device: Final = device
@@ -112,7 +112,7 @@ class DpUpdate(CallbackDataPoint, PayloadMixin):
             kind=DataPointCategory.UPDATE,
         )
 
-    def register_data_point_updated_callback(self, cb: Callable, custom_id: str) -> CALLBACK_TYPE:
+    def register_data_point_updated_callback(self, *, cb: Callable, custom_id: str) -> CALLBACK_TYPE:
         """Register update callback."""
         if custom_id != DEFAULT_CUSTOM_ID:
             if self._custom_id is not None:
@@ -121,18 +121,18 @@ class DpUpdate(CallbackDataPoint, PayloadMixin):
                 )
             self._custom_id = custom_id
 
-        if self._device.register_firmware_update_callback(cb) is not None:
+        if self._device.register_firmware_update_callback(cb=cb) is not None:
             return partial(self._unregister_data_point_updated_callback, cb=cb, custom_id=custom_id)
         return None
 
-    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."""
         if custom_id is not None:
             self._custom_id = None
-        self._device.unregister_firmware_update_callback(cb)
+        self._device.unregister_firmware_update_callback(cb=cb)
 
     @inspector
-    async def update_firmware(self, refresh_after_update_intervals: tuple[int, ...]) -> bool:
+    async def update_firmware(self, *, refresh_after_update_intervals: tuple[int, ...]) -> bool:
         """Turn the update on."""
         return await self._device.update_firmware(refresh_after_update_intervals=refresh_after_update_intervals)
 

aiohomematic/property_decorators.py

@@ -65,6 +65,8 @@ class _GenericProperty[GETTER, SETTER](property):
 
     """
 
+    __kwonly_check__ = False
+
     fget: Callable[[Any], GETTER] | None
     fset: Callable[[Any, SETTER], None] | None
     fdel: Callable[[Any], None] | None