aiohomematic 2025.10.0__py3-none-any.whl → 2025.10.2__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)
@@ -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)
 
@@ -127,7 +127,7 @@ class DataPointNameData(ChannelNameData):
             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/support.py

@@ -54,7 +54,7 @@ from aiohomematic.property_decorators import Kind, get_hm_property_by_kind, get_
 _LOGGER: Final = logging.getLogger(__name__)
 
 
-def extract_exc_args(exc: Exception) -> tuple[Any, ...] | Any:
+def extract_exc_args(*, exc: Exception) -> tuple[Any, ...] | Any:
     """Return the first arg, if there is only one arg."""
     if exc.args:
         return exc.args[0] if len(exc.args) == 1 else exc.args
@@ -62,6 +62,7 @@ def extract_exc_args(exc: Exception) -> tuple[Any, ...] | Any:
 
 
 def build_xml_rpc_uri(
+    *,
     host: str,
     port: int | None,
     path: str | None,
@@ -80,6 +81,7 @@ def build_xml_rpc_uri(
 
 
 def build_xml_rpc_headers(
+    *,
     username: str,
     password: str,
 ) -> list[tuple[str, str]]:
@@ -90,6 +92,7 @@ def build_xml_rpc_headers(
 
 
 def check_config(
+    *,
     central_name: str,
     host: str,
     username: str,
@@ -111,10 +114,10 @@ def check_config(
         config_failures.append("Username must not be empty")
     if not password:
         config_failures.append("Password is required")
-    if not check_password(password):
+    if not check_password(password=password):
         config_failures.append("Password is not valid")
     try:
-        check_or_create_directory(storage_folder)
+        check_or_create_directory(directory=storage_folder)
     except BaseHomematicException as bhexc:
         config_failures.append(extract_exc_args(exc=bhexc)[0])
     if callback_host and not (is_hostname(hostname=callback_host) or is_ipv4_address(address=callback_host)):
@@ -129,7 +132,7 @@ def check_config(
     return config_failures
 
 
-def has_primary_client(interface_configs: AbstractSet[hmcl.InterfaceConfig]) -> bool:
+def has_primary_client(*, interface_configs: AbstractSet[hmcl.InterfaceConfig]) -> bool:
     """Check if all configured clients exists in central."""
     for interface_config in interface_configs:
         if interface_config.interface in PRIMARY_CLIENT_CANDIDATE_INTERFACES:
@@ -137,7 +140,7 @@ def has_primary_client(interface_configs: AbstractSet[hmcl.InterfaceConfig]) ->
     return False
 
 
-def delete_file(folder: str, file_name: str) -> None:
+def delete_file(*, folder: str, file_name: str) -> None:
     """Delete the file."""
     file_path = os.path.join(folder, file_name)
     if (
@@ -148,7 +151,7 @@ def delete_file(folder: str, file_name: str) -> None:
         os.unlink(file_path)
 
 
-def check_or_create_directory(directory: str) -> bool:
+def check_or_create_directory(*, directory: str) -> bool:
     """Check / create directory."""
     if not directory:
         return False
@@ -162,12 +165,12 @@ def check_or_create_directory(directory: str) -> bool:
     return True
 
 
-def parse_sys_var(data_type: SysvarType | None, raw_value: Any) -> Any:
+def parse_sys_var(*, data_type: SysvarType | None, raw_value: Any) -> Any:
     """Parse system variables to fix type."""
     if not data_type:
         return raw_value
     if data_type in (SysvarType.ALARM, SysvarType.LOGIC):
-        return to_bool(raw_value)
+        return to_bool(value=raw_value)
     if data_type == SysvarType.FLOAT:
         return float(raw_value)
     if data_type in (SysvarType.INTEGER, SysvarType.LIST):
@@ -175,7 +178,7 @@ def parse_sys_var(data_type: SysvarType | None, raw_value: Any) -> Any:
     return raw_value
 
 
-def to_bool(value: Any) -> bool:
+def to_bool(*, value: Any) -> bool:
     """Convert defined string values to bool."""
     if isinstance(value, bool):
         return value
@@ -186,7 +189,7 @@ def to_bool(value: Any) -> bool:
     return value.lower() in ["y", "yes", "t", "true", "on", "1"]
 
 
-def check_password(password: str | None) -> bool:
+def check_password(*, password: str | None) -> bool:
     """Check password."""
     if password is None:
         return False
@@ -200,7 +203,7 @@ def check_password(password: str | None) -> bool:
     return True
 
 
-def regular_to_default_dict_hook(origin: dict) -> defaultdict[Any, Any]:
+def regular_to_default_dict_hook(origin: dict, /) -> defaultdict[Any, Any]:
     """Use defaultdict in json.loads object_hook."""
     new_dict: Callable = lambda: defaultdict(new_dict)
     new_instance = new_dict()
@@ -208,7 +211,7 @@ def regular_to_default_dict_hook(origin: dict) -> defaultdict[Any, Any]:
     return cast(defaultdict[Any, Any], new_instance)
 
 
-def _create_tls_context(verify_tls: bool) -> ssl.SSLContext:
+def _create_tls_context(*, verify_tls: bool) -> ssl.SSLContext:
     """Create tls verified/unverified context."""
     sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
     if not verify_tls:
@@ -225,48 +228,48 @@ _DEFAULT_NO_VERIFY_SSL_CONTEXT = _create_tls_context(verify_tls=False)
 _DEFAULT_SSL_CONTEXT = _create_tls_context(verify_tls=True)
 
 
-def get_tls_context(verify_tls: bool) -> ssl.SSLContext:
+def get_tls_context(*, verify_tls: bool) -> ssl.SSLContext:
     """Return tls verified/unverified context."""
     return _DEFAULT_SSL_CONTEXT if verify_tls else _DEFAULT_NO_VERIFY_SSL_CONTEXT
 
 
-def get_channel_address(device_address: str, channel_no: int | None) -> str:
+def get_channel_address(*, device_address: str, channel_no: int | None) -> str:
     """Return the channel address."""
     return device_address if channel_no is None else f"{device_address}:{channel_no}"
 
 
-def get_device_address(address: str) -> str:
+def get_device_address(*, address: str) -> str:
     """Return the device part of an address."""
     return get_split_channel_address(channel_address=address)[0]
 
 
-def get_channel_no(address: str) -> int | None:
+def get_channel_no(*, address: str) -> int | None:
     """Return the channel part of an address."""
     return get_split_channel_address(channel_address=address)[1]
 
 
-def is_address(address: str) -> bool:
+def is_address(*, address: str) -> bool:
     """Check if it is a address."""
     return is_device_address(address=address) or is_channel_address(address=address)
 
 
-def is_channel_address(address: str) -> bool:
+def is_channel_address(*, address: str) -> bool:
     """Check if it is a channel address."""
     return CHANNEL_ADDRESS_PATTERN.match(address) is not None
 
 
-def is_device_address(address: str) -> bool:
+def is_device_address(*, address: str) -> bool:
     """Check if it is a device address."""
     return DEVICE_ADDRESS_PATTERN.match(address) is not None
 
 
-def is_paramset_key(paramset_key: ParamsetKey | str) -> bool:
+def is_paramset_key(*, paramset_key: ParamsetKey | str) -> bool:
     """Check if it is a paramset key."""
     return isinstance(paramset_key, ParamsetKey) or (isinstance(paramset_key, str) and paramset_key in ParamsetKey)
 
 
 @lru_cache(maxsize=4096)
-def get_split_channel_address(channel_address: str) -> tuple[str, int | None]:
+def get_split_channel_address(*, channel_address: str) -> tuple[str, int | None]:
     """
     Return the device part of an address.
 
@@ -281,7 +284,7 @@ def get_split_channel_address(channel_address: str) -> tuple[str, int | None]:
     return channel_address, None
 
 
-def changed_within_seconds(last_change: datetime, max_age: int = MAX_CACHE_AGE) -> bool:
+def changed_within_seconds(*, last_change: datetime, max_age: int = MAX_CACHE_AGE) -> bool:
     """DataPoint has been modified within X minutes."""
     if last_change == INIT_DATETIME:
         return False
@@ -297,7 +300,7 @@ def find_free_port() -> int:
         return int(sock.getsockname()[1])
 
 
-def get_ip_addr(host: str, port: int) -> str | None:
+def get_ip_addr(host: str, port: int, /) -> str | None:
     """Get local_ip from socket."""
     try:
         socket.gethostbyname(host)
@@ -314,7 +317,7 @@ def get_ip_addr(host: str, port: int) -> str | None:
     return local_ip
 
 
-def is_hostname(hostname: str | None) -> bool:
+def is_hostname(*, hostname: str | None) -> bool:
     """Return True if hostname is valid."""
     if not hostname:
         return False
@@ -333,7 +336,7 @@ def is_hostname(hostname: str | None) -> bool:
     return all(ALLOWED_HOSTNAME_PATTERN.match(label) for label in labels)
 
 
-def is_ipv4_address(address: str | None) -> bool:
+def is_ipv4_address(*, address: str | None) -> bool:
     """Return True if ipv4_address is valid."""
     if not address:
         return False
@@ -344,12 +347,13 @@ def is_ipv4_address(address: str | None) -> bool:
     return True
 
 
-def is_port(port: int) -> bool:
+def is_port(*, port: int) -> bool:
     """Return True if port is valid."""
     return 0 <= port <= 65535
 
 
 def element_matches_key(
+    *,
     search_elements: str | Collection[str],
     compare_with: str | None,
     search_key: str | None = None,
@@ -401,7 +405,7 @@ def element_matches_key(
     return False
 
 
-def _get_search_key(search_elements: Collection[str], search_key: str) -> str | None:
+def _get_search_key(*, search_elements: Collection[str], search_key: str) -> str | None:
     """Search for a matching key in a collection."""
     for element in search_elements:
         if search_key.startswith(element):
@@ -446,7 +450,7 @@ def debug_enabled() -> bool:
     return False
 
 
-def hash_sha256(value: Any) -> str:
+def hash_sha256(*, value: Any) -> str:
     """
     Hash a value with sha256.
 
@@ -459,26 +463,26 @@ def hash_sha256(value: Any) -> str:
         data = orjson.dumps(value, option=orjson.OPT_SORT_KEYS | orjson.OPT_NON_STR_KEYS)
     except Exception:
         # Fallback: convert to a hashable representation and use repr()
-        data = repr(_make_value_hashable(value)).encode()
+        data = repr(_make_value_hashable(value=value)).encode()
     hasher.update(data)
     return base64.b64encode(hasher.digest()).decode()
 
 
-def _make_value_hashable(value: Any) -> Any:
+def _make_value_hashable(*, value: Any) -> Any:
     """Make a hashable object."""
     if isinstance(value, tuple | list):
-        return tuple(_make_value_hashable(e) for e in value)
+        return tuple(_make_value_hashable(value=e) for e in value)
 
     if isinstance(value, dict):
-        return tuple(sorted((k, _make_value_hashable(v)) for k, v in value.items()))
+        return tuple(sorted((k, _make_value_hashable(value=v)) for k, v in value.items()))
 
     if isinstance(value, set | frozenset):
-        return tuple(sorted(_make_value_hashable(e) for e in value))
+        return tuple(sorted(_make_value_hashable(value=e) for e in value))
 
     return value
 
 
-def get_rx_modes(mode: int) -> tuple[RxMode, ...]:
+def get_rx_modes(*, mode: int) -> tuple[RxMode, ...]:
     """Convert int to rx modes."""
     rx_modes: set[RxMode] = set()
     if mode & RxMode.LAZY_CONFIG:
@@ -498,14 +502,14 @@ def get_rx_modes(mode: int) -> tuple[RxMode, ...]:
     return tuple(rx_modes)
 
 
-def supports_rx_mode(command_rx_mode: CommandRxMode, rx_modes: tuple[RxMode, ...]) -> bool:
+def supports_rx_mode(*, command_rx_mode: CommandRxMode, rx_modes: tuple[RxMode, ...]) -> bool:
     """Check if rx mode is supported."""
     return (command_rx_mode == CommandRxMode.BURST and RxMode.BURST in rx_modes) or (
         command_rx_mode == CommandRxMode.WAKEUP and RxMode.WAKEUP in rx_modes
     )
 
 
-def cleanup_text_from_html_tags(text: str) -> str:
+def cleanup_text_from_html_tags(*, text: str) -> str:
     """Cleanup text from html tags."""
     return re.sub(HTMLTAG_PATTERN, "", text)
 
@@ -515,7 +519,7 @@ def cleanup_text_from_html_tags(text: str) -> str:
 _BOUNDARY_MSG = "error_boundary"
 
 
-def _safe_log_context(context: Mapping[str, Any] | None) -> dict[str, Any]:
+def _safe_log_context(*, context: Mapping[str, Any] | None) -> dict[str, Any]:
     """Extract safe context from a mapping."""
     ctx: dict[str, Any] = {}
     if not context:
@@ -565,7 +569,9 @@ def log_boundary_error(
         log_message += f" {message}"
 
     if log_context:
-        log_message += f" ctx={orjson.dumps(_safe_log_context(log_context), option=orjson.OPT_SORT_KEYS).decode()}"
+        log_message += (
+            f" ctx={orjson.dumps(_safe_log_context(context=log_context), option=orjson.OPT_SORT_KEYS).decode()}"
+        )
 
     # Choose level if not provided:
     if (chosen_level := level) is None: