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

aiohomematic/async_support.py

@@ -28,7 +28,7 @@ class Looper:
         self._tasks: Final[set[asyncio.Future[Any]]] = set()
         self._loop = asyncio.get_event_loop()
 
-    async def block_till_done(self, wait_time: float | None = None) -> None:
+    async def block_till_done(self, *, wait_time: float | None = None) -> None:
         """
         Block until all pending work is done.
 
@@ -39,14 +39,14 @@ class Looper:
         start_time: float | None = None
         deadline: float | None = (monotonic() + wait_time) if wait_time is not None else None
         current_task = asyncio.current_task()
-        while tasks := [task for task in self._tasks if task is not current_task and not cancelling(task)]:
+        while tasks := [task for task in self._tasks if task is not current_task and not cancelling(task=task)]:
             # If we have a deadline and have exceeded it, log remaining tasks and break
             if deadline is not None and monotonic() >= deadline:
                 for task in tasks:
                     _LOGGER.warning("Shutdown timeout reached; task still pending: %s", task)
                 break
 
-            await self._await_and_log_pending(tasks)
+            await self._await_and_log_pending(pending=tasks)
 
             if start_time is None:
                 # Avoid calling monotonic() until we know
@@ -63,7 +63,7 @@ class Looper:
                 for task in tasks:
                     _LOGGER.debug("Waiting for task: %s", task)
 
-    async def _await_and_log_pending(self, pending: Collection[asyncio.Future[Any]]) -> None:
+    async def _await_and_log_pending(self, *, pending: Collection[asyncio.Future[Any]]) -> None:
         """Await and log tasks that take a long time."""
         wait_time = 0
         while pending:
@@ -74,7 +74,7 @@ class Looper:
             for task in pending:
                 _LOGGER.debug("Waited %s seconds for task: %s", wait_time, task)
 
-    def create_task(self, target: Coroutine[Any, Any, Any], name: str) -> None:
+    def create_task(self, *, target: Coroutine[Any, Any, Any], name: str) -> None:
         """Add task to the executor pool."""
         try:
             self._loop.call_soon_threadsafe(self._async_create_task, target, name)
@@ -92,7 +92,7 @@ class Looper:
         task.add_done_callback(self._tasks.remove)
         return task
 
-    def run_coroutine(self, coro: Coroutine, name: str) -> Any:
+    def run_coroutine(self, *, coro: Coroutine, name: str) -> Any:
         """Call coroutine from sync."""
         try:
             return asyncio.run_coroutine_threadsafe(coro, self._loop).result()
@@ -128,7 +128,7 @@ class Looper:
                 task.cancel()
 
 
-def cancelling(task: asyncio.Future[Any]) -> bool:
+def cancelling(*, task: asyncio.Future[Any]) -> bool:
     """Return True if task is cancelling."""
     return bool((cancelling_ := getattr(task, "cancelling", None)) and cancelling_())
 

aiohomematic/caches/dynamic.py

@@ -60,7 +60,7 @@ class CommandCache:
         "_last_send_command",
     )
 
-    def __init__(self, interface_id: str) -> None:
+    def __init__(self, *, interface_id: str) -> None:
         """Init command cache."""
         self._interface_id: Final = interface_id
         # (paramset_key, device_address, channel_no, parameter)
@@ -68,6 +68,7 @@ class CommandCache:
 
     def add_set_value(
         self,
+        *,
         channel_address: str,
         parameter: str,
         value: Any,
@@ -89,7 +90,7 @@ class CommandCache:
         return {(dpk, value)}
 
     def add_put_paramset(
-        self, channel_address: str, paramset_key: ParamsetKey, values: dict[str, Any]
+        self, *, channel_address: str, paramset_key: ParamsetKey, values: dict[str, Any]
     ) -> set[DP_KEY_VALUE]:
         """Add data from put paramset command."""
         dpk_values: set[DP_KEY_VALUE] = set()
@@ -106,10 +107,10 @@ class CommandCache:
         return dpk_values
 
     def add_combined_parameter(
-        self, parameter: str, channel_address: str, combined_parameter: str
+        self, *, parameter: str, channel_address: str, combined_parameter: str
     ) -> set[DP_KEY_VALUE]:
         """Add data from combined parameter."""
-        if values := convert_combined_parameter_to_paramset(parameter=parameter, cpv=combined_parameter):
+        if values := convert_combined_parameter_to_paramset(parameter=parameter, value=combined_parameter):
             return self.add_put_paramset(
                 channel_address=channel_address,
                 paramset_key=ParamsetKey.VALUES,
@@ -117,7 +118,7 @@ class CommandCache:
             )
         return set()
 
-    def get_last_value_send(self, dpk: DataPointKey, max_age: int = LAST_COMMAND_SEND_STORE_TIMEOUT) -> Any:
+    def get_last_value_send(self, *, dpk: DataPointKey, max_age: int = LAST_COMMAND_SEND_STORE_TIMEOUT) -> Any:
         """Return the last send values."""
         if result := self._last_send_command.get(dpk):
             value, last_send_dt = result
@@ -131,6 +132,7 @@ class CommandCache:
 
     def remove_last_value_send(
         self,
+        *,
         dpk: DataPointKey,
         value: Any = None,
         max_age: int = LAST_COMMAND_SEND_STORE_TIMEOUT,
@@ -158,7 +160,7 @@ class DeviceDetailsCache:
         "_refreshed_at",
     )
 
-    def __init__(self, central: hmcu.CentralUnit) -> None:
+    def __init__(self, *, central: hmcu.CentralUnit) -> None:
         """Init the device details cache."""
         self._central: Final = central
         self._channel_rooms: Final[dict[str, set[str]]] = defaultdict(set)
@@ -169,7 +171,7 @@ class DeviceDetailsCache:
         self._names_cache: Final[dict[str, str]] = {}
         self._refreshed_at = INIT_DATETIME
 
-    async def load(self, direct_call: bool = False) -> None:
+    async def load(self, *, direct_call: bool = False) -> None:
         """Fetch names from the backend."""
         if direct_call is False and changed_within_seconds(
             last_change=self._refreshed_at, max_age=int(MAX_CACHE_AGE / 3)
@@ -194,27 +196,27 @@ class DeviceDetailsCache:
         """Return device channel ids."""
         return self._device_channel_ids
 
-    def add_name(self, address: str, name: str) -> None:
+    def add_name(self, *, address: str, name: str) -> None:
         """Add name to cache."""
         self._names_cache[address] = name
 
-    def get_name(self, address: str) -> str | None:
+    def get_name(self, *, address: str) -> str | None:
         """Get name from cache."""
         return self._names_cache.get(address)
 
-    def add_interface(self, address: str, interface: Interface) -> None:
+    def add_interface(self, *, address: str, interface: Interface) -> None:
         """Add interface to cache."""
         self._interface_cache[address] = interface
 
-    def get_interface(self, address: str) -> Interface:
+    def get_interface(self, *, address: str) -> Interface:
         """Get interface from cache."""
         return self._interface_cache.get(address) or Interface.BIDCOS_RF
 
-    def add_address_id(self, address: str, hmid: str) -> None:
+    def add_address_id(self, *, address: str, hmid: str) -> None:
         """Add channel id for a channel."""
         self._device_channel_ids[address] = hmid
 
-    def get_address_id(self, address: str) -> str:
+    def get_address_id(self, *, address: str) -> str:
         """Get id for address."""
         return self._device_channel_ids.get(address) or "0"
 
@@ -232,11 +234,11 @@ class DeviceDetailsCache:
                 _device_rooms[get_device_address(address=channel_address)].update(rooms)
         return _device_rooms
 
-    def get_device_rooms(self, device_address: str) -> set[str]:
+    def get_device_rooms(self, *, device_address: str) -> set[str]:
         """Return all rooms by device_address."""
         return set(self._device_rooms.get(device_address, ()))
 
-    def get_channel_rooms(self, channel_address: str) -> set[str]:
+    def get_channel_rooms(self, *, channel_address: str) -> set[str]:
         """Return rooms by channel_address."""
         return self._channel_rooms[channel_address]
 
@@ -246,13 +248,13 @@ class DeviceDetailsCache:
             return await client.get_all_functions()
         return {}
 
-    def get_function_text(self, address: str) -> str | None:
+    def get_function_text(self, *, address: str) -> str | None:
         """Return function by address."""
         if functions := self._functions.get(address):
             return ",".join(functions)
         return None
 
-    def remove_device(self, device: Device) -> None:
+    def remove_device(self, *, device: Device) -> None:
         """Remove name from cache."""
         if device.address in self._names_cache:
             del self._names_cache[device.address]
@@ -278,14 +280,14 @@ class CentralDataCache:
         "_value_cache",
     )
 
-    def __init__(self, central: hmcu.CentralUnit) -> None:
+    def __init__(self, *, central: hmcu.CentralUnit) -> None:
         """Init the central data cache."""
         self._central: Final = central
         # { key, value}
         self._value_cache: Final[dict[Interface, Mapping[str, Any]]] = {}
         self._refreshed_at: Final[dict[Interface, datetime]] = {}
 
-    async def load(self, direct_call: bool = False, interface: Interface | None = None) -> None:
+    async def load(self, *, direct_call: bool = False, interface: Interface | None = None) -> None:
         """Fetch data from the backend."""
         _LOGGER.debug("load: Loading device data for %s", self._central.name)
         for client in self._central.clients:
@@ -300,6 +302,7 @@ class CentralDataCache:
 
     async def refresh_data_point_data(
         self,
+        *,
         paramset_key: ParamsetKey | None = None,
         interface: Interface | None = None,
         direct_call: bool = False,
@@ -308,13 +311,14 @@ class CentralDataCache:
         for dp in self._central.get_readable_generic_data_points(paramset_key=paramset_key, interface=interface):
             await dp.load_data_point_value(call_source=CallSource.HM_INIT, direct_call=direct_call)
 
-    def add_data(self, interface: Interface, all_device_data: Mapping[str, Any]) -> None:
+    def add_data(self, *, interface: Interface, all_device_data: Mapping[str, Any]) -> None:
         """Add data to cache."""
         self._value_cache[interface] = all_device_data
         self._refreshed_at[interface] = datetime.now()
 
     def get_data(
         self,
+        *,
         interface: Interface,
         channel_address: str,
         parameter: str,
@@ -324,7 +328,7 @@ class CentralDataCache:
             return iface_cache.get(f"{interface}.{channel_address}.{parameter}", NO_CACHE_ENTRY)
         return NO_CACHE_ENTRY
 
-    def clear(self, interface: Interface | None = None) -> None:
+    def clear(self, *, interface: Interface | None = None) -> None:
         """Clear the cache."""
         if interface:
             self._value_cache[interface] = {}
@@ -333,11 +337,11 @@ class CentralDataCache:
             for _interface in self._central.interfaces:
                 self.clear(interface=_interface)
 
-    def _get_refreshed_at(self, interface: Interface) -> datetime:
+    def _get_refreshed_at(self, *, interface: Interface) -> datetime:
         """Return when cache has been refreshed."""
         return self._refreshed_at.get(interface, INIT_DATETIME)
 
-    def _is_empty(self, interface: Interface) -> bool:
+    def _is_empty(self, *, interface: Interface) -> bool:
         """Return if cache is empty for the given interface."""
         # If there is no data stored for the requested interface, treat as empty.
         if not self._value_cache.get(interface):
@@ -365,6 +369,7 @@ class PingPongCache:
 
     def __init__(
         self,
+        *,
         central: hmcu.CentralUnit,
         interface_id: str,
         allowed_delta: int = PING_PONG_MISMATCH_COUNT,
@@ -422,7 +427,7 @@ class PingPongCache:
         self._pending_pong_logged = False
         self._unknown_pong_logged = False
 
-    def handle_send_ping(self, ping_ts: datetime) -> None:
+    def handle_send_ping(self, *, ping_ts: datetime) -> None:
         """Handle send ping timestamp."""
         self._pending_pongs.add(ping_ts)
         self._check_and_fire_pong_event(
@@ -436,7 +441,7 @@ class PingPongCache:
             ping_ts,
         )
 
-    def handle_received_pong(self, pong_ts: datetime) -> None:
+    def handle_received_pong(self, *, pong_ts: datetime) -> None:
         """Handle received pong timestamp."""
         if pong_ts in self._pending_pongs:
             self._pending_pongs.remove(pong_ts)
@@ -492,7 +497,7 @@ class PingPongCache:
                     pong_ts,
                 )
 
-    def _check_and_fire_pong_event(self, event_type: InterfaceEventType, pong_mismatch_count: int) -> None:
+    def _check_and_fire_pong_event(self, *, event_type: InterfaceEventType, pong_mismatch_count: int) -> None:
         """Fire an event about the pong status."""
 
         def _fire_event(mismatch_count: int) -> None:

aiohomematic/caches/persistent.py

@@ -89,6 +89,7 @@ class BasePersistentCache(ABC):
 
     def __init__(
         self,
+        *,
         central: hmcu.CentralUnit,
         persistent_cache: dict[str, Any],
     ) -> None:
@@ -145,14 +146,14 @@ class BasePersistentCache(ABC):
         """Determine if save operation should proceed."""
         self.last_save_triggered = datetime.now()
         return (
-            check_or_create_directory(self._cache_dir)
+            check_or_create_directory(directory=self._cache_dir)
             and self._central.config.use_caches
             and self.cache_hash != self.last_hash_saved
         )
 
     async def load(self) -> DataOperationResult:
         """Load data from disk into the dictionary."""
-        if not check_or_create_directory(self._cache_dir) or not os.path.exists(self._file_path):
+        if not check_or_create_directory(directory=self._cache_dir) or not os.path.exists(self._file_path):
             return DataOperationResult.NO_LOAD
 
         def _perform_load() -> DataOperationResult:
@@ -195,7 +196,7 @@ class DeviceDescriptionCache(BasePersistentCache):
 
     _file_postfix = FILE_DEVICES
 
-    def __init__(self, central: hmcu.CentralUnit) -> None:
+    def __init__(self, *, central: hmcu.CentralUnit) -> None:
         """Initialize the device description cache."""
         # {interface_id, [device_descriptions]}
         self._raw_device_descriptions: Final[dict[str, list[DeviceDescription]]] = defaultdict(list)
@@ -208,7 +209,7 @@ class DeviceDescriptionCache(BasePersistentCache):
         # {interface_id, {address, device_descriptions}}
         self._device_descriptions: Final[dict[str, dict[str, DeviceDescription]]] = defaultdict(dict)
 
-    def add_device(self, interface_id: str, device_description: DeviceDescription) -> None:
+    def add_device(self, *, interface_id: str, device_description: DeviceDescription) -> None:
         """Add a device to the cache."""
         # Fast-path: If the address is not yet known, skip costly removal operations.
         if (address := device_description["ADDRESS"]) not in self._device_descriptions[interface_id]:
@@ -223,18 +224,18 @@ class DeviceDescriptionCache(BasePersistentCache):
         self._raw_device_descriptions[interface_id].append(device_description)
         self._process_device_description(interface_id=interface_id, device_description=device_description)
 
-    def get_raw_device_descriptions(self, interface_id: str) -> list[DeviceDescription]:
+    def get_raw_device_descriptions(self, *, interface_id: str) -> list[DeviceDescription]:
         """Retrieve raw device descriptions from the cache."""
         return self._raw_device_descriptions[interface_id]
 
-    def remove_device(self, device: Device) -> None:
+    def remove_device(self, *, device: Device) -> None:
         """Remove device from cache."""
         self._remove_device(
             interface_id=device.interface_id,
             addresses_to_remove=[device.address, *device.channels.keys()],
         )
 
-    def _remove_device(self, interface_id: str, addresses_to_remove: list[str]) -> None:
+    def _remove_device(self, *, interface_id: str, addresses_to_remove: list[str]) -> None:
         """Remove a device from the cache."""
         # Use a set for faster membership checks
         addresses_set = set(addresses_to_remove)
@@ -249,23 +250,23 @@ class DeviceDescriptionCache(BasePersistentCache):
                 addr_map.pop(address, None)
             desc_map.pop(address, None)
 
-    def get_addresses(self, interface_id: str) -> frozenset[str]:
+    def get_addresses(self, *, interface_id: str) -> frozenset[str]:
         """Return the addresses by interface as a set."""
         return frozenset(self._addresses[interface_id])
 
-    def get_device_descriptions(self, interface_id: str) -> Mapping[str, DeviceDescription]:
+    def get_device_descriptions(self, *, interface_id: str) -> Mapping[str, DeviceDescription]:
         """Return the devices by interface."""
         return self._device_descriptions[interface_id]
 
-    def find_device_description(self, interface_id: str, device_address: str) -> DeviceDescription | None:
+    def find_device_description(self, *, interface_id: str, device_address: str) -> DeviceDescription | None:
         """Return the device description by interface and device_address."""
         return self._device_descriptions[interface_id].get(device_address)
 
-    def get_device_description(self, interface_id: str, address: str) -> DeviceDescription:
+    def get_device_description(self, *, interface_id: str, address: str) -> DeviceDescription:
         """Return the device description by interface and device_address."""
         return self._device_descriptions[interface_id][address]
 
-    def get_device_with_channels(self, interface_id: str, device_address: str) -> Mapping[str, DeviceDescription]:
+    def get_device_with_channels(self, *, interface_id: str, device_address: str) -> Mapping[str, DeviceDescription]:
         """Return the device dict by interface and device_address."""
         device_descriptions: dict[str, DeviceDescription] = {
             device_address: self.get_device_description(interface_id=interface_id, address=device_address)
@@ -277,22 +278,22 @@ class DeviceDescriptionCache(BasePersistentCache):
             )
         return device_descriptions
 
-    def get_model(self, device_address: str) -> str | None:
+    def get_model(self, *, device_address: str) -> str | None:
         """Return the device type."""
         for data in self._device_descriptions.values():
             if items := data.get(device_address):
                 return items["TYPE"]
         return None
 
-    def _convert_device_descriptions(self, interface_id: str, device_descriptions: list[DeviceDescription]) -> None:
+    def _convert_device_descriptions(self, *, interface_id: str, device_descriptions: list[DeviceDescription]) -> None:
         """Convert provided list of device descriptions."""
         for device_description in device_descriptions:
             self._process_device_description(interface_id=interface_id, device_description=device_description)
 
-    def _process_device_description(self, interface_id: str, device_description: DeviceDescription) -> None:
+    def _process_device_description(self, *, interface_id: str, device_description: DeviceDescription) -> None:
         """Convert provided dict of device descriptions."""
         address = device_description["ADDRESS"]
-        device_address = get_device_address(address)
+        device_address = get_device_address(address=address)
         self._device_descriptions[interface_id][address] = device_description
 
         # Avoid redundant membership checks; set.add is idempotent and cheaper than check+add
@@ -310,7 +311,7 @@ class DeviceDescriptionCache(BasePersistentCache):
                 interface_id,
                 device_descriptions,
             ) in self._raw_device_descriptions.items():
-                self._convert_device_descriptions(interface_id, device_descriptions)
+                self._convert_device_descriptions(interface_id=interface_id, device_descriptions=device_descriptions)
         return result
 
 
@@ -324,7 +325,7 @@ class ParamsetDescriptionCache(BasePersistentCache):
 
     _file_postfix = FILE_PARAMSETS
 
-    def __init__(self, central: hmcu.CentralUnit) -> None:
+    def __init__(self, *, central: hmcu.CentralUnit) -> None:
         """Init the paramset description cache."""
         # {interface_id, {channel_address, paramsets}}
         self._raw_paramset_descriptions: Final[dict[str, dict[str, dict[ParamsetKey, dict[str, ParameterData]]]]] = (
@@ -347,6 +348,7 @@ class ParamsetDescriptionCache(BasePersistentCache):
 
     def add(
         self,
+        *,
         interface_id: str,
         channel_address: str,
         paramset_key: ParamsetKey,
@@ -356,49 +358,49 @@ class ParamsetDescriptionCache(BasePersistentCache):
         self._raw_paramset_descriptions[interface_id][channel_address][paramset_key] = paramset_description
         self._add_address_parameter(channel_address=channel_address, paramsets=[paramset_description])
 
-    def remove_device(self, device: Device) -> None:
+    def remove_device(self, *, device: Device) -> None:
         """Remove device paramset descriptions from cache."""
         if interface := self._raw_paramset_descriptions.get(device.interface_id):
             for channel_address in device.channels:
                 if channel_address in interface:
                     del self._raw_paramset_descriptions[device.interface_id][channel_address]
 
-    def has_interface_id(self, interface_id: str) -> bool:
+    def has_interface_id(self, *, interface_id: str) -> bool:
         """Return if interface is in paramset_descriptions cache."""
         return interface_id in self._raw_paramset_descriptions
 
-    def get_paramset_keys(self, interface_id: str, channel_address: str) -> tuple[ParamsetKey, ...]:
+    def get_paramset_keys(self, *, interface_id: str, channel_address: str) -> tuple[ParamsetKey, ...]:
         """Get paramset_keys from paramset descriptions cache."""
         return tuple(self._raw_paramset_descriptions[interface_id][channel_address])
 
     def get_channel_paramset_descriptions(
-        self, interface_id: str, channel_address: str
+        self, *, interface_id: str, channel_address: str
     ) -> Mapping[ParamsetKey, Mapping[str, ParameterData]]:
         """Get paramset descriptions for a channelfrom cache."""
         return self._raw_paramset_descriptions[interface_id].get(channel_address, {})
 
     def get_paramset_descriptions(
-        self, interface_id: str, channel_address: str, paramset_key: ParamsetKey
+        self, *, interface_id: str, channel_address: str, paramset_key: ParamsetKey
     ) -> Mapping[str, ParameterData]:
         """Get paramset descriptions from cache."""
         return self._raw_paramset_descriptions[interface_id][channel_address][paramset_key]
 
     def get_parameter_data(
-        self, interface_id: str, channel_address: str, paramset_key: ParamsetKey, parameter: str
+        self, *, interface_id: str, channel_address: str, paramset_key: ParamsetKey, parameter: str
     ) -> ParameterData | None:
         """Get parameter_data  from cache."""
         return self._raw_paramset_descriptions[interface_id][channel_address][paramset_key].get(parameter)
 
-    def is_in_multiple_channels(self, channel_address: str, parameter: str) -> bool:
+    def is_in_multiple_channels(self, *, channel_address: str, parameter: str) -> bool:
         """Check if parameter is in multiple channels per device."""
         if ADDRESS_SEPARATOR not in channel_address:
             return False
-        if channels := self._address_parameter_cache.get((get_device_address(channel_address), parameter)):
+        if channels := self._address_parameter_cache.get((get_device_address(address=channel_address), parameter)):
             return len(channels) > 1
         return False
 
     def get_channel_addresses_by_paramset_key(
-        self, interface_id: str, device_address: str
+        self, *, interface_id: str, device_address: str
     ) -> Mapping[ParamsetKey, list[str]]:
         """Get device channel addresses."""
         channel_addresses: dict[ParamsetKey, list[str]] = {}
@@ -425,9 +427,9 @@ class ParamsetDescriptionCache(BasePersistentCache):
             for channel_address, paramsets in channel_paramsets.items():
                 self._add_address_parameter(channel_address=channel_address, paramsets=list(paramsets.values()))
 
-    def _add_address_parameter(self, channel_address: str, paramsets: list[dict[str, Any]]) -> None:
+    def _add_address_parameter(self, *, channel_address: str, paramsets: list[dict[str, Any]]) -> None:
         """Add address parameter to cache."""
-        device_address, channel_no = get_split_channel_address(channel_address)
+        device_address, channel_no = get_split_channel_address(channel_address=channel_address)
         cache = self._address_parameter_cache
         for paramset in paramsets:
             if not paramset:
@@ -449,17 +451,17 @@ class ParamsetDescriptionCache(BasePersistentCache):
         return await super().save()
 
 
-def _get_cache_path(storage_folder: str) -> str:
+def _get_cache_path(*, storage_folder: str) -> str:
     """Return the cache path."""
     return f"{storage_folder}/{CACHE_PATH}"
 
 
-def _get_filename(central_name: str, file_name: str) -> str:
+def _get_filename(*, central_name: str, file_name: str) -> str:
     """Return the cache filename."""
     return f"{slugify(central_name)}_{file_name}"
 
 
-def cleanup_cache_dirs(central_name: str, storage_folder: str) -> None:
+def cleanup_cache_dirs(*, central_name: str, storage_folder: str) -> None:
     """Clean up the used cached directories."""
     cache_dir = _get_cache_path(storage_folder=storage_folder)
     for file_to_delete in (FILE_DEVICES, FILE_PARAMSETS):

aiohomematic/caches/visibility.py

@@ -239,7 +239,7 @@ _IGNORED_PARAMETERS_START_RE: Final = re.compile(
 )
 
 
-def _parameter_is_wildcard_ignored(parameter: TParameterName) -> bool:
+def _parameter_is_wildcard_ignored(*, parameter: TParameterName) -> bool:
     """Check if a parameter matches common wildcard patterns."""
     return bool(_IGNORED_PARAMETERS_END_RE.match(parameter) or _IGNORED_PARAMETERS_START_RE.match(parameter))
 
@@ -260,7 +260,7 @@ _UN_IGNORE_PARAMETERS_BY_MODEL_LOWER: Final[dict[TModelName, frozenset[Parameter
 
 
 @cache
-def _get_parameters_for_model_prefix(model_prefix: str | None) -> frozenset[Parameter] | None:
+def _get_parameters_for_model_prefix(*, model_prefix: str | None) -> frozenset[Parameter] | None:
     """Return the dict value by wildcard type."""
     if model_prefix is None:
         return None
@@ -359,6 +359,7 @@ class ParameterVisibilityCache:
 
     def __init__(
         self,
+        *,
         central: hmcu.CentralUnit,
     ) -> None:
         """Init the parameter visibility cache."""
@@ -419,7 +420,7 @@ class ParameterVisibilityCache:
         self._process_un_ignore_entries(lines=self._raw_un_ignores)
 
     def _resolve_prefix_key(
-        self, model_l: TModelName, mapping: Mapping[str, object], cache_dict: dict[TModelName, str | None]
+        self, *, model_l: TModelName, mapping: Mapping[str, object], cache_dict: dict[TModelName, str | None]
     ) -> str | None:
         """Resolve and memoize the first key in mapping that prefixes model_l."""
         dt_short_key = cache_dict.get(model_l)
@@ -428,7 +429,7 @@ class ParameterVisibilityCache:
             cache_dict[model_l] = dt_short_key
         return dt_short_key
 
-    def model_is_ignored(self, model: TModelName) -> bool:
+    def model_is_ignored(self, *, model: TModelName) -> bool:
         """Check if a model should be ignored for custom data points."""
         return element_matches_key(
             search_elements=self._ignore_custom_device_definition_models,
@@ -437,6 +438,7 @@ class ParameterVisibilityCache:
 
     def parameter_is_ignored(
         self,
+        *,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
         parameter: TParameterName,
@@ -506,6 +508,7 @@ class ParameterVisibilityCache:
 
     def _parameter_is_un_ignored(
         self,
+        *,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
         parameter: TParameterName,
@@ -555,6 +558,7 @@ class ParameterVisibilityCache:
 
     def parameter_is_un_ignored(
         self,
+        *,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
         parameter: TParameterName,
@@ -590,7 +594,12 @@ class ParameterVisibilityCache:
         )
 
     def should_skip_parameter(
-        self, channel: hmd.Channel, paramset_key: ParamsetKey, parameter: TParameterName, parameter_is_un_ignored: bool
+        self,
+        *,
+        channel: hmd.Channel,
+        paramset_key: ParamsetKey,
+        parameter: TParameterName,
+        parameter_is_un_ignored: bool,
     ) -> bool:
         """Determine if a parameter should be skipped."""
         if self.parameter_is_ignored(
@@ -613,7 +622,7 @@ class ParameterVisibilityCache:
 
         return paramset_key == ParamsetKey.MASTER and not parameter_is_un_ignored
 
-    def _process_un_ignore_entries(self, lines: Iterable[str]) -> None:
+    def _process_un_ignore_entries(self, *, lines: Iterable[str]) -> None:
         """Batch process un_ignore entries into cache."""
         for line in lines:
             # ignore empty line
@@ -637,7 +646,7 @@ class ParameterVisibilityCache:
                 )
 
     def _get_un_ignore_line_details(
-        self, line: str
+        self, *, line: str
     ) -> tuple[TModelName, TUnIgnoreChannelNo, TParameterName, ParamsetKey] | str | None:
         """
         Check the format of the line for un_ignore file.
@@ -715,6 +724,7 @@ class ParameterVisibilityCache:
 
     def _add_complex_un_ignore_entry(
         self,
+        *,
         model: TModelName,
         channel_no: TUnIgnoreChannelNo,
         paramset_key: ParamsetKey,
@@ -739,6 +749,7 @@ class ParameterVisibilityCache:
 
     def parameter_is_hidden(
         self,
+        *,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
         parameter: TParameterName,
@@ -757,6 +768,7 @@ class ParameterVisibilityCache:
 
     def is_relevant_paramset(
         self,
+        *,
         channel: hmd.Channel,
         paramset_key: ParamsetKey,
     ) -> bool: