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

aiohomematic/model/device.py

@@ -131,7 +131,7 @@ class Device(LogContextMixin, PayloadMixin):
         "_value_cache",
     )
 
-    def __init__(self, central: hmcu.CentralUnit, interface_id: str, device_address: str) -> None:
+    def __init__(self, *, central: hmcu.CentralUnit, interface_id: str, device_address: str) -> None:
         """Initialize the device object."""
         PayloadMixin.__init__(self)
         self._central: Final = central
@@ -164,7 +164,7 @@ class Device(LogContextMixin, PayloadMixin):
             model=self._model
         )
         self._manufacturer = self._identify_manufacturer()
-        self._product_group: Final = self._client.get_product_group(self._model)
+        self._product_group: Final = self._client.get_product_group(model=self._model)
         # marker if device will be created as custom data_point
         self._has_custom_data_point_definition: Final = (
             hmed.data_point_definition_exists(model=self._model) and not self._ignore_for_custom_data_point
@@ -431,7 +431,7 @@ class Device(LogContextMixin, PayloadMixin):
         """Return th CONFIG_PENDING data_point."""
         return self.get_generic_data_point(channel_address=f"{self._address}:0", parameter=Parameter.CONFIG_PENDING)
 
-    def add_channel_to_group(self, group_no: int, channel_no: int | None) -> None:
+    def add_channel_to_group(self, *, group_no: int, channel_no: int | None) -> None:
         """Add channel to group."""
         if group_no not in self._group_channels:
             self._group_channels[group_no] = set()
@@ -464,22 +464,22 @@ class Device(LogContextMixin, PayloadMixin):
             and self._model not in VIRTUAL_REMOTE_MODELS
         )
 
-    def get_channel_group_no(self, channel_no: int | None) -> int | None:
+    def get_channel_group_no(self, *, channel_no: int | None) -> int | None:
         """Return the group no of the channel."""
         return self._channel_group.get(channel_no)
 
-    def is_in_multi_channel_group(self, channel_no: int | None) -> bool:
+    def is_in_multi_channel_group(self, *, channel_no: int | None) -> bool:
         """Return if multiple channels are in the group."""
         if channel_no is None:
             return False
 
         return len([s for s, m in self._channel_group.items() if m == self._channel_group.get(channel_no)]) > 1
 
-    def get_channel(self, channel_address: str) -> Channel | None:
+    def get_channel(self, *, channel_address: str) -> Channel | None:
         """Get channel of device."""
         return self._channels.get(channel_address)
 
-    def identify_channel(self, text: str) -> Channel | None:
+    def identify_channel(self, *, text: str) -> Channel | None:
         """Identify channel within a text."""
         for channel_address, channel in self._channels.items():
             if text.endswith(channel_address):
@@ -496,26 +496,26 @@ class Device(LogContextMixin, PayloadMixin):
         for channel in self._channels.values():
             channel.remove()
 
-    def register_device_updated_callback(self, cb: Callable) -> CALLBACK_TYPE:
+    def register_device_updated_callback(self, *, cb: Callable) -> CALLBACK_TYPE:
         """Register update callback."""
         if callable(cb) and cb not in self._device_updated_callbacks:
             self._device_updated_callbacks.append(cb)
             return partial(self.unregister_device_updated_callback, cb=cb)
         return None
 
-    def unregister_device_updated_callback(self, cb: Callable) -> None:
+    def unregister_device_updated_callback(self, *, cb: Callable) -> None:
         """Remove update callback."""
         if cb in self._device_updated_callbacks:
             self._device_updated_callbacks.remove(cb)
 
-    def register_firmware_update_callback(self, cb: Callable) -> CALLBACK_TYPE:
+    def register_firmware_update_callback(self, *, cb: Callable) -> CALLBACK_TYPE:
         """Register firmware update callback."""
         if callable(cb) and cb not in self._firmware_update_callbacks:
             self._firmware_update_callbacks.append(cb)
             return partial(self.unregister_firmware_update_callback, cb=cb)
         return None
 
-    def unregister_firmware_update_callback(self, cb: Callable) -> None:
+    def unregister_firmware_update_callback(self, *, cb: Callable) -> None:
         """Remove firmware update callback."""
         if cb in self._firmware_update_callbacks:
             self._firmware_update_callbacks.remove(cb)
@@ -525,6 +525,7 @@ class Device(LogContextMixin, PayloadMixin):
 
     def get_data_points(
         self,
+        *,
         category: DataPointCategory | None = None,
         exclude_no_create: bool = True,
         registered: bool | None = None,
@@ -548,7 +549,7 @@ class Device(LogContextMixin, PayloadMixin):
         return tuple(all_data_points)
 
     def get_events(
-        self, event_type: EventType, registered: bool | None = None
+        self, *, event_type: EventType, registered: bool | None = None
     ) -> Mapping[int | None, tuple[GenericEvent, ...]]:
         """Return a list of specific events of a channel."""
         events: dict[int | None, tuple[GenericEvent, ...]] = {}
@@ -557,13 +558,13 @@ class Device(LogContextMixin, PayloadMixin):
                 events[channel.no] = values
         return events
 
-    def get_calculated_data_point(self, channel_address: str, parameter: str) -> CalculatedDataPoint | None:
+    def get_calculated_data_point(self, *, channel_address: str, parameter: str) -> CalculatedDataPoint | None:
         """Return a calculated data_point from device."""
         if channel := self.get_channel(channel_address=channel_address):
             return channel.get_calculated_data_point(parameter=parameter)
         return None
 
-    def get_custom_data_point(self, channel_no: int) -> hmce.CustomDataPoint | None:
+    def get_custom_data_point(self, *, channel_no: int) -> hmce.CustomDataPoint | None:
         """Return a custom data_point from device."""
         if channel := self.get_channel(
             channel_address=get_channel_address(device_address=self._address, channel_no=channel_no)
@@ -572,27 +573,27 @@ class Device(LogContextMixin, PayloadMixin):
         return None
 
     def get_generic_data_point(
-        self, channel_address: str, parameter: str, paramset_key: ParamsetKey | None = None
+        self, *, channel_address: str, parameter: str, paramset_key: ParamsetKey | None = None
     ) -> GenericDataPoint | None:
         """Return a generic data_point from device."""
         if channel := self.get_channel(channel_address=channel_address):
             return channel.get_generic_data_point(parameter=parameter, paramset_key=paramset_key)
         return None
 
-    def get_generic_event(self, channel_address: str, parameter: str) -> GenericEvent | None:
+    def get_generic_event(self, *, channel_address: str, parameter: str) -> GenericEvent | None:
         """Return a generic event from device."""
         if channel := self.get_channel(channel_address=channel_address):
             return channel.get_generic_event(parameter=parameter)
         return None
 
-    def get_readable_data_points(self, paramset_key: ParamsetKey) -> tuple[GenericDataPoint, ...]:
+    def get_readable_data_points(self, *, paramset_key: ParamsetKey) -> tuple[GenericDataPoint, ...]:
         """Return the list of readable master data points."""
         data_points: list[GenericDataPoint] = []
         for channel in self._channels.values():
             data_points.extend(channel.get_readable_data_points(paramset_key=paramset_key))
         return tuple(data_points)
 
-    def set_forced_availability(self, forced_availability: ForcedDeviceAvailability) -> None:
+    def set_forced_availability(self, *, forced_availability: ForcedDeviceAvailability) -> None:
         """Set the availability of the device."""
         if self._forced_availability != forced_availability:
             self._forced_availability = forced_availability
@@ -629,7 +630,7 @@ class Device(LogContextMixin, PayloadMixin):
                 callback_handler()
 
     @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:
         """Update the firmware of the Homematic device."""
         update_result = await self._client.update_device_firmware(device_address=self._address)
 
@@ -676,12 +677,12 @@ class Device(LogContextMixin, PayloadMixin):
         self.fire_device_updated_callback()
 
     @loop_check
-    def fire_device_updated_callback(self, *args: Any) -> None:
+    def fire_device_updated_callback(self) -> None:
         """Do what is needed when the state of the device has been updated."""
         self._set_modified_at()
         for callback_handler in self._device_updated_callbacks:
             try:
-                callback_handler(*args)
+                callback_handler()
             except Exception as exc:
                 _LOGGER.warning("FIRE_DEVICE_UPDATED failed: %s", extract_exc_args(exc=exc))
 
@@ -724,7 +725,7 @@ class Channel(LogContextMixin, PayloadMixin):
         "_unique_id",
     )
 
-    def __init__(self, device: Device, channel_address: str) -> None:
+    def __init__(self, *, device: Device, channel_address: str) -> None:
         """Initialize the channel object."""
         PayloadMixin.__init__(self)
 
@@ -809,7 +810,9 @@ class Channel(LogContextMixin, PayloadMixin):
             return None
         if self._group_master is None:
             self._group_master = (
-                self if self.is_group_master else self._device.get_channel(f"{self._device.address}:{self.group_no}")
+                self
+                if self.is_group_master
+                else self._device.get_channel(channel_address=f"{self._device.address}:{self.group_no}")
             )
         return self._group_master
 
@@ -952,7 +955,7 @@ class Channel(LogContextMixin, PayloadMixin):
         """Return if channel has KEYPRESS events."""
         return any(event for event in self.generic_events if event.event_type is EventType.KEYPRESS)
 
-    def add_data_point(self, data_point: CallbackDataPoint) -> None:
+    def add_data_point(self, *, data_point: CallbackDataPoint) -> None:
         """Add a data_point to a channel."""
         if isinstance(data_point, BaseParameterDataPoint):
             self._central.add_event_subscription(data_point=data_point)
@@ -966,7 +969,7 @@ class Channel(LogContextMixin, PayloadMixin):
         if isinstance(data_point, GenericEvent):
             self._generic_events[data_point.dpk] = data_point
 
-    def _remove_data_point(self, data_point: CallbackDataPoint) -> None:
+    def _remove_data_point(self, *, data_point: CallbackDataPoint) -> None:
         """Remove a data_point from a channel."""
         if isinstance(data_point, BaseParameterDataPoint):
             self._central.remove_event_subscription(data_point=data_point)
@@ -984,25 +987,26 @@ class Channel(LogContextMixin, PayloadMixin):
     def remove(self) -> None:
         """Remove data points from collections and central."""
         for event in self.generic_events:
-            self._remove_data_point(event)
+            self._remove_data_point(data_point=event)
         self._generic_events.clear()
 
         for ccdp in self.calculated_data_points:
-            self._remove_data_point(ccdp)
+            self._remove_data_point(data_point=ccdp)
         self._calculated_data_points.clear()
 
         for gdp in self.generic_data_points:
-            self._remove_data_point(gdp)
+            self._remove_data_point(data_point=gdp)
         self._generic_data_points.clear()
 
         if self._custom_data_point:
-            self._remove_data_point(self._custom_data_point)
+            self._remove_data_point(data_point=self._custom_data_point)
 
     def _set_modified_at(self) -> None:
         self._modified_at = datetime.now()
 
     def get_data_points(
         self,
+        *,
         category: DataPointCategory | None = None,
         exclude_no_create: bool = True,
         registered: bool | None = None,
@@ -1023,7 +1027,7 @@ class Channel(LogContextMixin, PayloadMixin):
             and (registered is None or dp.is_registered == registered)
         )
 
-    def get_events(self, event_type: EventType, registered: bool | None = None) -> tuple[GenericEvent, ...]:
+    def get_events(self, *, event_type: EventType, registered: bool | None = None) -> tuple[GenericEvent, ...]:
         """Return a list of specific events of a channel."""
         return tuple(
             event
@@ -1031,7 +1035,7 @@ class Channel(LogContextMixin, PayloadMixin):
             if (event.event_type == event_type and (registered is None or event.is_registered == registered))
         )
 
-    def get_calculated_data_point(self, parameter: str) -> CalculatedDataPoint | None:
+    def get_calculated_data_point(self, *, parameter: str) -> CalculatedDataPoint | None:
         """Return a calculated data_point from device."""
         return self._calculated_data_points.get(
             DataPointKey(
@@ -1043,7 +1047,7 @@ class Channel(LogContextMixin, PayloadMixin):
         )
 
     def get_generic_data_point(
-        self, parameter: str, paramset_key: ParamsetKey | None = None
+        self, *, parameter: str, paramset_key: ParamsetKey | None = None
     ) -> GenericDataPoint | None:
         """Return a generic data_point from device."""
         if paramset_key:
@@ -1074,7 +1078,7 @@ class Channel(LogContextMixin, PayloadMixin):
             )
         )
 
-    def get_generic_event(self, parameter: str) -> GenericEvent | None:
+    def get_generic_event(self, *, parameter: str) -> GenericEvent | None:
         """Return a generic event from device."""
         return self._generic_events.get(
             DataPointKey(
@@ -1085,7 +1089,7 @@ class Channel(LogContextMixin, PayloadMixin):
             )
         )
 
-    def get_readable_data_points(self, paramset_key: ParamsetKey) -> tuple[GenericDataPoint, ...]:
+    def get_readable_data_points(self, *, paramset_key: ParamsetKey) -> tuple[GenericDataPoint, ...]:
         """Return the list of readable master data points."""
         return tuple(
             ge for ge in self._generic_data_points.values() if ge.is_readable and ge.paramset_key == paramset_key
@@ -1114,7 +1118,7 @@ class _ValueCache:
 
     _NO_VALUE_CACHE_ENTRY: Final = "NO_VALUE_CACHE_ENTRY"
 
-    def __init__(self, device: Device) -> None:
+    def __init__(self, *, device: Device) -> None:
         """Init the value cache."""
         self._sema_get_or_load_value: Final = asyncio.Semaphore()
         self._device: Final = device
@@ -1166,6 +1170,7 @@ class _ValueCache:
 
     async def get_value(
         self,
+        *,
         dpk: DataPointKey,
         call_source: CallSource,
         direct_call: bool = False,
@@ -1204,7 +1209,7 @@ class _ValueCache:
                 else value
             )
 
-    async def _get_values_for_cache(self, dpk: DataPointKey) -> dict[str, Any]:
+    async def _get_values_for_cache(self, *, dpk: DataPointKey) -> dict[str, Any]:
         """Return a value from the backend to store in cache."""
         if not self._device.available:
             _LOGGER.debug(
@@ -1224,7 +1229,7 @@ class _ValueCache:
             address=dpk.channel_address, paramset_key=dpk.paramset_key, call_source=CallSource.HM_INIT
         )
 
-    def _add_entry_to_device_cache(self, dpk: DataPointKey, value: Any) -> None:
+    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 the backend within max_age
@@ -1232,6 +1237,7 @@ class _ValueCache:
 
     def _get_value_from_cache(
         self,
+        *,
         dpk: DataPointKey,
     ) -> Any:
         """Load data from caches."""
@@ -1266,7 +1272,7 @@ class _DefinitionExporter:
         "_storage_folder",
     )
 
-    def __init__(self, device: Device) -> None:
+    def __init__(self, *, device: Device) -> None:
         """Init the device exporter."""
         self._client: Final = device.client
         self._central: Final = device.client.central
@@ -1298,7 +1304,7 @@ class _DefinitionExporter:
                 new_device_description["PARENT"] = new_device_description["ADDRESS"].split(ADDRESS_SEPARATOR)[0]
             elif new_device_description.get("CHILDREN"):
                 new_device_description["CHILDREN"] = [
-                    self._anonymize_address(a) for a in new_device_description["CHILDREN"]
+                    self._anonymize_address(address=a) for a in new_device_description["CHILDREN"]
                 ]
             anonymize_device_descriptions.append(new_device_description)
 
@@ -1321,16 +1327,16 @@ class _DefinitionExporter:
             data=anonymize_paramset_descriptions,
         )
 
-    def _anonymize_address(self, address: str) -> str:
+    def _anonymize_address(self, *, address: str) -> str:
         address_parts = address.split(ADDRESS_SEPARATOR)
         address_parts[0] = self._random_id
         return ADDRESS_SEPARATOR.join(address_parts)
 
-    async def _save(self, file_dir: str, filename: str, data: Any) -> DataOperationResult:
+    async def _save(self, *, file_dir: str, filename: str, data: Any) -> DataOperationResult:
         """Save file to disk."""
 
         def perform_save() -> DataOperationResult:
-            if not check_or_create_directory(file_dir):
+            if not check_or_create_directory(directory=file_dir):
                 return DataOperationResult.NO_SAVE  # pragma: no cover
             with open(
                 file=os.path.join(file_dir, filename),

aiohomematic/model/event.py

@@ -73,6 +73,7 @@ class GenericEvent(BaseParameterDataPoint[Any, Any]):
 
     def __init__(
         self,
+        *,
         channel: hmd.Channel,
         parameter: str,
         parameter_data: ParameterData,
@@ -98,15 +99,15 @@ class GenericEvent(BaseParameterDataPoint[Any, Any]):
         """Return the event_type of the event."""
         return self._event_type
 
-    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 handler has subscribed."""
         if self.event_type in DATA_POINT_EVENTS:
             self.fire_data_point_updated_callback()
         self._set_modified_at(modified_at=received_at)
-        self.fire_event(value)
+        self.fire_event(value=value)
 
     @loop_check
-    def fire_event(self, value: Any) -> None:
+    def fire_event(self, *, value: Any) -> None:
         """Do what is needed to fire an event."""
         self._central.fire_homematic_callback(event_type=self.event_type, event_data=self.get_event_data(value=value))
 
@@ -137,7 +138,7 @@ class DeviceErrorEvent(GenericEvent):
 
     _event_type = EventType.DEVICE_ERROR
 
-    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 handler has subscribed."""
         old_value, new_value = self.write_value(value=value, write_at=received_at)
 
@@ -173,7 +174,7 @@ def create_event_and_append_to_channel(channel: hmd.Channel, parameter: str, par
             event_t=event_t, channel=channel, parameter=parameter, parameter_data=parameter_data
         )
     ):
-        channel.add_data_point(event)
+        channel.add_data_point(data_point=event)
 
 
 def _determine_event_type(parameter: str, parameter_data: ParameterData) -> type[GenericEvent] | None:

aiohomematic/model/generic/__init__.py

@@ -102,6 +102,7 @@ _SWITCH_DP_TO_SENSOR: Final[Mapping[str | tuple[str, ...], Parameter]] = {
 
 @inspector
 def create_data_point_and_append_to_channel(
+    *,
     channel: hmd.Channel,
     paramset_key: ParamsetKey,
     parameter: str,
@@ -115,7 +116,7 @@ def create_data_point_and_append_to_channel(
         channel.device.interface_id,
     )
 
-    if (dp_t := _determine_data_point_type(channel, parameter, parameter_data)) and (
+    if (dp_t := _determine_data_point_type(channel=channel, parameter=parameter, parameter_data=parameter_data)) and (
         dp := _safe_create_data_point(
             dp_t=dp_t, channel=channel, paramset_key=paramset_key, parameter=parameter, parameter_data=parameter_data
         )
@@ -126,13 +127,13 @@ def create_data_point_and_append_to_channel(
             channel.address,
             parameter,
         )
-        channel.add_data_point(dp)
+        channel.add_data_point(data_point=dp)
         if _check_switch_to_sensor(data_point=dp):
             dp.force_to_sensor()
 
 
 def _determine_data_point_type(
-    channel: hmd.Channel, parameter: str, parameter_data: ParameterData
+    *, channel: hmd.Channel, parameter: str, parameter_data: ParameterData
 ) -> type[GenericDataPoint] | None:
     """Determine the type of data point based on parameter and operations."""
     p_type = parameter_data["TYPE"]
@@ -173,6 +174,7 @@ def _determine_data_point_type(
 
 
 def _safe_create_data_point(
+    *,
     dp_t: type[GenericDataPoint],
     channel: hmd.Channel,
     paramset_key: ParamsetKey,
@@ -193,7 +195,7 @@ def _safe_create_data_point(
         ) from exc
 
 
-def _check_switch_to_sensor(data_point: GenericDataPoint) -> bool:
+def _check_switch_to_sensor(*, data_point: GenericDataPoint) -> bool:
     """Check if parameter of a device should be wrapped to a different category."""
     if data_point.device.central.parameter_visibility.parameter_is_un_ignored(
         channel=data_point.channel,

aiohomematic/model/generic/action.py

@@ -27,7 +27,7 @@ class DpAction(GenericDataPoint[None, Any]):
     _category = DataPointCategory.ACTION
     _validate_state_change = False
 
-    def _prepare_value_for_sending(self, value: Any, do_validate: bool = True) -> Any:
+    def _prepare_value_for_sending(self, *, value: Any, do_validate: bool = True) -> Any:
         """Prepare value before sending."""
         if (index := get_index_of_value_from_value_list(value=value, value_list=self._values)) is not None:
             return index

aiohomematic/model/generic/data_point.py

@@ -38,6 +38,7 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
 
     def __init__(
         self,
+        *,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
         parameter: str,
@@ -60,7 +61,7 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             return self._get_data_point_usage()
         return DataPointUsage.DATA_POINT if force_enabled else DataPointUsage.NO_CREATE  # pylint: disable=using-constant-test
 
-    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._device.client.last_value_send_cache.remove_last_value_send(
             dpk=self.dpk,
@@ -82,15 +83,16 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             Parameter.UN_REACH,
             Parameter.STICKY_UN_REACH,
         ):
-            self._device.fire_device_updated_callback(self._unique_id)
+            self._device.fire_device_updated_callback()
             self._central.fire_homematic_callback(
                 event_type=EventType.DEVICE_AVAILABILITY,
-                event_data=self.get_event_data(new_value),
+                event_data=self.get_event_data(value=new_value),
             )
 
     @inspector
     async def send_value(
         self,
+        *,
         value: InputParameterT,
         collector: hme.CallParameterCollector | None = None,
         collector_order: int = 50,
@@ -123,7 +125,7 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             value=converted_value,
         )
 
-    def _prepare_value_for_sending(self, value: InputParameterT, do_validate: bool = True) -> ParameterT:
+    def _prepare_value_for_sending(self, *, value: InputParameterT, do_validate: bool = True) -> ParameterT:
         """Prepare value, if required, before send."""
         return value  # type: ignore[return-value]
 
@@ -151,7 +153,7 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             else DataPointUsage.DATA_POINT
         )
 
-    def is_state_change(self, value: ParameterT) -> bool:
+    def is_state_change(self, *, value: ParameterT) -> bool:
         """
         Check if the state/value changes.
 

aiohomematic/model/generic/number.py

@@ -24,7 +24,7 @@ class BaseDpNumber[NumberParameterT: int | float | None](GenericDataPoint[Number
     _category = DataPointCategory.NUMBER
 
     def _prepare_number_for_sending(
-        self, value: int | float | str, type_converter: type, do_validate: bool = True
+        self, *, value: int | float | str, type_converter: type, do_validate: bool = True
     ) -> NumberParameterT:
         """Prepare value before sending."""
         if not do_validate or (
@@ -47,7 +47,7 @@ class DpFloat(BaseDpNumber[float | None]):
 
     __slots__ = ()
 
-    def _prepare_value_for_sending(self, value: int | float | str, do_validate: bool = True) -> float | None:
+    def _prepare_value_for_sending(self, *, value: int | float | str, do_validate: bool = True) -> float | None:
         """Prepare value before sending."""
         return self._prepare_number_for_sending(value=value, type_converter=float, do_validate=do_validate)
 
@@ -66,7 +66,7 @@ class DpInteger(BaseDpNumber[int | None]):
 
     __slots__ = ()
 
-    def _prepare_value_for_sending(self, value: int | float | str, do_validate: bool = True) -> int | None:
+    def _prepare_value_for_sending(self, *, value: int | float | str, do_validate: bool = True) -> int | None:
         """Prepare value before sending."""
         return self._prepare_number_for_sending(value=value, type_converter=int, do_validate=do_validate)
 

aiohomematic/model/generic/select.py

@@ -29,7 +29,7 @@ class DpSelect(GenericDataPoint[int | str, int | float | str]):
             return value
         return str(self._default)
 
-    def _prepare_value_for_sending(self, value: int | float | str, do_validate: bool = True) -> int:
+    def _prepare_value_for_sending(self, *, value: int | float | str, do_validate: bool = True) -> int:
         """Prepare value before sending."""
         # We allow setting the value via index as well, just in case.
         if isinstance(value, int | float) and self._values and 0 <= value < len(self._values):

aiohomematic/model/generic/sensor.py

@@ -33,7 +33,7 @@ class DpSensor[SensorT: float | int | str | None](GenericDataPoint[SensorT, None
         if (value := get_value_from_value_list(value=self._value, value_list=self.values)) is not None:
             return cast(SensorT, value)
         if convert_func := self._get_converter_func():
-            return cast(SensorT, convert_func(self._value))
+            return cast(SensorT, convert_func(value=self._value))
         return cast(
             SensorT,
             check_length_and_log(name=self.name, value=self._value)
@@ -48,7 +48,7 @@ class DpSensor[SensorT: float | int | str | None](GenericDataPoint[SensorT, None
         return None
 
 
-def _fix_rssi(value: Any) -> int | None:
+def _fix_rssi(*, value: Any) -> int | None:
     """
     Fix rssi value.
 

aiohomematic/model/generic/switch.py

@@ -32,19 +32,19 @@ class DpSwitch(GenericDataPoint[bool | None, bool]):
         return cast(bool | None, self._value)
 
     @inspector
-    async def turn_on(self, collector: CallParameterCollector | None = None, on_time: float | None = None) -> None:
+    async def turn_on(self, *, on_time: float | None = None, collector: CallParameterCollector | None = None) -> None:
         """Turn the switch on."""
         if on_time is not None:
             await self.set_on_time(on_time=on_time)
         await self.send_value(value=True, collector=collector)
 
     @inspector
-    async def turn_off(self, collector: CallParameterCollector | None = None) -> None:
+    async def turn_off(self, *, collector: CallParameterCollector | None = None) -> None:
         """Turn the switch off."""
         await self.send_value(value=False, collector=collector)
 
     @inspector
-    async def set_on_time(self, on_time: float) -> None:
+    async def set_on_time(self, *, on_time: float) -> None:
         """Set the on time value in seconds."""
         await self._client.set_value(
             channel_address=self._channel.address,