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

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:

aiohomematic/validator.py

@@ -28,42 +28,42 @@ positive_int = vol.All(vol.Coerce(int), vol.Range(min=0))
 wait_for = vol.All(vol.Coerce(int), vol.Range(min=1, max=MAX_WAIT_FOR_CALLBACK))
 
 
-def channel_address(value: str) -> str:
+def channel_address(value: str, /) -> str:
     """Validate channel_address."""
     if is_channel_address(address=value):
         return value
     raise vol.Invalid("channel_address is invalid")
 
 
-def device_address(value: str) -> str:
+def device_address(value: str, /) -> str:
     """Validate channel_address."""
     if is_device_address(address=value):
         return value
     raise vol.Invalid("device_address is invalid")
 
 
-def hostname(value: str) -> str:
+def hostname(value: str, /) -> str:
     """Validate hostname."""
     if is_hostname(hostname=value):
         return value
     raise vol.Invalid("hostname is invalid")
 
 
-def ipv4_address(value: str) -> str:
+def ipv4_address(value: str, /) -> str:
     """Validate ipv4_address."""
     if is_ipv4_address(address=value):
         return value
     raise vol.Invalid("ipv4_address is invalid")
 
 
-def password(value: str) -> str:
+def password(value: str, /) -> str:
     """Validate password."""
     if check_password(password=value):
         return value
     raise vol.Invalid("password is invalid")
 
 
-def paramset_key(value: str) -> str:
+def paramset_key(value: str, /) -> str:
     """Validate paramset_key."""
     if is_paramset_key(paramset_key=value):
         return value

{aiohomematic-2025.10.1.dist-info → aiohomematic-2025.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.1
+Version: 2025.10.3
 Summary: Homematic interface for Home Assistant running on Python 3.
 Home-page: https://github.com/sukramj/aiohomematic
 Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>

aiohomematic-2025.10.3.dist-info/RECORD

@@ -0,0 +1,78 @@
+aiohomematic/__init__.py,sha256=ngULK_anZQwwUUCVcberBdVjguYfboiuG9VoueKy9fA,2283
+aiohomematic/async_support.py,sha256=EEzOwI3LAWjl16Q2QgtTLS7P9ktodBvs8Cw3ZKsjyxw,6153
+aiohomematic/const.py,sha256=mJmfDFhm3NFQP4qkRlb63d89qi-pDidoHUq0RYYOM6I,25565
+aiohomematic/context.py,sha256=M7gkA7KFT0dp35gzGz2dzKVXu1PP0sAnepgLlmjyRS4,451
+aiohomematic/converter.py,sha256=gaNHe-WEiBStZMuuRz9iGn3Mo_CGz1bjgLtlYBJJAko,3624
+aiohomematic/decorators.py,sha256=oHEFSJoJVd-h9RYb6NLTJ60erkpRHPYv7EEipKn1a9Q,10636
+aiohomematic/exceptions.py,sha256=8Uu3rADawhYlAz6y4J52aJ-wKok8Z7YbUYUwWeGMKhs,5028
+aiohomematic/hmcli.py,sha256=qNstNDX6q8t3mJFCGlXlmRVobGabntrPtFi3kchf1Eg,4933
+aiohomematic/property_decorators.py,sha256=tAsmcSDnLsUiWlD1KUEe5fvYoIGpk5syYB0DrGuN4QU,16231
+aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiohomematic/support.py,sha256=w05YlO1IrelF2a1zKkUGWyr5E-nDJ-knh0LQqOHpR34,20514
+aiohomematic/validator.py,sha256=HUikmo-SFksehFBAdZmBv4ajy0XkjgvXvcCfbexnzZo,3563
+aiohomematic/caches/__init__.py,sha256=_gI30tbsWgPRaHvP6cRxOQr6n9bYZzU-jp1WbHhWg-A,470
+aiohomematic/caches/dynamic.py,sha256=vyQsjBc2uGoNCCrWPMGmNBlUQ9GYvgVuupA9bhqH5hI,21466
+aiohomematic/caches/persistent.py,sha256=2bgASru4zbrFEd8rOn2YcReeHPiPJE8hMgMUPAbGh68,20117
+aiohomematic/caches/visibility.py,sha256=SThfEO3LKbIIERD4Novyj4ZZUkcYrBuvYdNQfPO29JQ,31676
+aiohomematic/central/__init__.py,sha256=nXbA9IYHSn-Gm59U_T9gqMeKwQxmliv3jdrkXnMtpXs,86940
+aiohomematic/central/decorators.py,sha256=v0gCa5QEQPNEvGy0O2YIOhoJy7OKiJZJWtK64OQm7y4,6918
+aiohomematic/central/xml_rpc_server.py,sha256=1Vr8BXakLSo-RC967IlRI9LPUCl4iXp2y-AXSZuDyPc,10777
+aiohomematic/client/__init__.py,sha256=XWHg8VTtiahu7jfHwq4yOVXOxUy8nw80JF9uyY7QNJI,70457
+aiohomematic/client/_rpc_errors.py,sha256=-NPtGvkQPJ4V2clDxv1tKy09M9JZm61pUCeki9DDh6s,2984
+aiohomematic/client/json_rpc.py,sha256=k5euUJkDzIQXdOX5JJxkua_7AUUTFspK8rTGnVKoCf8,49568
+aiohomematic/client/xml_rpc.py,sha256=9PEOWoTG0EMUAMyqiInF4iA_AduHv_hhjJW3YhYjYqU,9614
+aiohomematic/model/__init__.py,sha256=KO7gas_eEzm67tODKqWTs0617CSGeKKjOWOlDbhRo_Q,5458
+aiohomematic/model/data_point.py,sha256=Ml8AOQ1RcRezTYWiGBlIXwcTLolQMX5Cyb-O7GtNDm4,41586
+aiohomematic/model/device.py,sha256=15z5G2X3jSJaj-yz7jX_tnirzipRIGBJPymObY3Dmjk,52942
+aiohomematic/model/event.py,sha256=82H8M_QNMCCC29mP3R16alJyKWS3Hb3aqY_aFMSqCvo,6874
+aiohomematic/model/support.py,sha256=l5E9Oon20nkGWOSEmbYtqQbpbh6-H4rIk8xtEtk5Fcg,19657
+aiohomematic/model/update.py,sha256=5F39xNz9B2GKJ8TvJHPMC-Wu97HfkiiMawjnHEYMnoA,5156
+aiohomematic/model/calculated/__init__.py,sha256=UGLePgKDH8JpLqjhPBgvBzjggI34omcaCPsc6tcM8Xs,2811
+aiohomematic/model/calculated/climate.py,sha256=GXBsC5tnrC_BvnFBkJ9KUqE7uVcGD1KTU_6-OleF5H4,8545
+aiohomematic/model/calculated/data_point.py,sha256=oTN8y3B9weh7CX3ZFiDyZFgvX77iUwge-acg49pd1sI,11609
+aiohomematic/model/calculated/operating_voltage_level.py,sha256=ZrOPdNoWQ5QLr4yzMRsoPG3UuJKRkBUHfchIrpKZU4o,13527
+aiohomematic/model/calculated/support.py,sha256=vOxTvWe8SBCwJpLzcVA8ibtfw4eP8yTUZj4Jt9hWt9k,6695
+aiohomematic/model/custom/__init__.py,sha256=UzczqjsUqWvS9ZaqKeb6elbjb2y5W3cgFPB0YQUHaeM,6095
+aiohomematic/model/custom/climate.py,sha256=zSLQUY_tU7tDlbM-vW15BGuyWRjcR_DyqOwSg1_Vmfw,57217
+aiohomematic/model/custom/const.py,sha256=Kh1pnab6nmwbaY43CfXQy3yrWpPwsrQdl1Ea2aZ6aw0,4961
+aiohomematic/model/custom/cover.py,sha256=hlIeQD0cZpq7X222J7ygm6kD4AE6h5IN-wcqzvZCLFA,29057
+aiohomematic/model/custom/data_point.py,sha256=l2pTz7Fu5jGCstXHK1cWCFfBWIJeKmtt37qdGLmrQhA,14155
+aiohomematic/model/custom/definition.py,sha256=9kSdqVOHQs65Q2Op5QknNQv5lLmZkZlGCUUCRGicOaw,35662
+aiohomematic/model/custom/light.py,sha256=2UxQOoupwTpQ-5iwY51gL_B815sgDXNW-HG-QhAFb9E,44448
+aiohomematic/model/custom/lock.py,sha256=ndzZ0hp7FBohw7T_qR0jPobwlcwxus9M1DuDu_7vfPw,11996
+aiohomematic/model/custom/siren.py,sha256=DT8RoOCl7FqstgRSBK-RWRcY4T29LuEdnlhaWCB6ATk,9785
+aiohomematic/model/custom/support.py,sha256=UvencsvCwgpm4iqRNRt5KRs560tyw1NhYP5ZaqmCT2k,1453
+aiohomematic/model/custom/switch.py,sha256=VKknWPJOtSwIzV-Ag_8Zg1evtkyjKh768Be_quU_R54,6885
+aiohomematic/model/custom/valve.py,sha256=u9RYzeJ8FNmpFO6amlLElXTQdAeqac5yo7NbZYS6Z9U,4242
+aiohomematic/model/generic/__init__.py,sha256=-ho8m9gFlORBGNPn2i8c9i5-GVLLFvTlf5FFpaTJbFw,7675
+aiohomematic/model/generic/action.py,sha256=niJPvTs43b9GiKomdBaBKwjOwtmNxR_YRhj5Fpje9NU,997
+aiohomematic/model/generic/binary_sensor.py,sha256=U5GvfRYbhwe0jRmaedD4LVZ_24SyyPbVr74HEfZXoxE,887
+aiohomematic/model/generic/button.py,sha256=6jZ49woI9gYJEx__PjguDNbc5vdE1P-YcLMZZFkYRCg,740
+aiohomematic/model/generic/data_point.py,sha256=2NvdU802JUo4NZh0v6oMI-pVtlNluSFse7ISMGqo70g,6084
+aiohomematic/model/generic/number.py,sha256=nJgOkMZwNfPtzBrX2o5RAjBt-o8KrKuqtDa9LBj0Jw0,2678
+aiohomematic/model/generic/select.py,sha256=vWfLUdQBjZLG-q-WZMxHk9Klawg_iNOEeSoVHrvG35I,1538
+aiohomematic/model/generic/sensor.py,sha256=wCnQ8IoC8uPTN29R250pfJa4x6y9sh4c3vxQ4Km8Clg,2262
+aiohomematic/model/generic/switch.py,sha256=VIMwIVok9kSRoSb-s5saYRHeiZcNWH4J5FyMSxUAbpw,1842
+aiohomematic/model/generic/text.py,sha256=vtNV7YxZuxF6LzNRKRAeOtSQtPQxPaEd560OFaVR13U,854
+aiohomematic/model/hub/__init__.py,sha256=g2m-5rba6SNCfGrlxwqYa8mlP5-N2obFAvyHJV8i4FY,13525
+aiohomematic/model/hub/binary_sensor.py,sha256=Z4o-zghHSc83ZHUUCtHqWEGueD9K1Fe0JEt_xJNdx_Y,752
+aiohomematic/model/hub/button.py,sha256=XMnoImnz5vDybxfrP4GWDp2M5gEMG71d8ba1YzVYAnE,890
+aiohomematic/model/hub/data_point.py,sha256=E6qn1gVhZ4meti-Tpd03f-YyfKnkUh-FpLbwBaa-d1c,10653
+aiohomematic/model/hub/number.py,sha256=12BK6mBOJn4aP7DWuWvMYfiaLmDX7ejd5tDCoHa2bUk,1237
+aiohomematic/model/hub/select.py,sha256=C9ke_8U_pzI0fctIeOZHwq-fvWj5s64jW6-DcZT-SrU,1674
+aiohomematic/model/hub/sensor.py,sha256=cIr-7bsbOLBxnH33EHQ6D42vc61abO4QYLWLzkm1T10,1192
+aiohomematic/model/hub/switch.py,sha256=510Vrlyak5TRsMvURrGYMkad-CbGUKWh20jjHQGOios,1390
+aiohomematic/model/hub/text.py,sha256=JOy-hfDSu95NbxP5JeGgga9NGrR8JLNmz_h4k8J1GXU,999
+aiohomematic/rega_scripts/fetch_all_device_data.fn,sha256=7uxhHoelAOsH6yYr1n1M1XwIRgDmItiHnWIMhDYEimk,4373
+aiohomematic/rega_scripts/get_program_descriptions.fn,sha256=pGmj377MkqbZi6j-UBKQAsXTphwh1kDwDKqXij8zUBE,835
+aiohomematic/rega_scripts/get_serial.fn,sha256=t1oeo-sB_EuVeiY24PLcxFSkdQVgEWGXzpemJQZFybY,1079
+aiohomematic/rega_scripts/get_system_variable_descriptions.fn,sha256=UKXvC0_5lSApdQ2atJc0E5Stj5Zt3lqh0EcliokYu2c,849
+aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m04cHjVj4kIOnUUgpY,279
+aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
+aiohomematic-2025.10.3.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic_support/__init__.py,sha256=_0YtF4lTdC_k6-zrM2IefI0u0LMr_WA61gXAyeGLgbY,66
+aiohomematic_support/client_local.py,sha256=CGZ6N_JCQ12_u2h56M_WCZ5SbcOK4xBsPYjLH2eyqlo,12820
+aiohomematic-2025.10.3.dist-info/METADATA,sha256=npEp8wqV-PrVJzhabx_yKlOicBz3Q7pnqrLf1nqqlLg,7603
+aiohomematic-2025.10.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.3.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
+aiohomematic-2025.10.3.dist-info/RECORD,,

aiohomematic_support/client_local.py

@@ -41,7 +41,7 @@ BACKEND_LOCAL: Final = "Local CCU"
 class ClientLocal(Client):  # pragma: no cover
     """Local client object to provide access to locally stored files."""
 
-    def __init__(self, client_config: _ClientConfig, local_resources: LocalRessources) -> None:
+    def __init__(self, *, client_config: _ClientConfig, local_resources: LocalRessources) -> None:
         """Initialize the Client."""
         super().__init__(client_config=client_config)
         self._local_resources = local_resources
@@ -63,7 +63,7 @@ class ClientLocal(Client):  # pragma: no cover
         """Return the model of the backend."""
         return BACKEND_LOCAL
 
-    def get_product_group(self, model: str) -> ProductGroup:
+    def get_product_group(self, *, model: str) -> ProductGroup:
         """Return the product group."""
         l_model = model.lower()
         if l_model.startswith("hmipw"):
@@ -120,46 +120,46 @@ class ClientLocal(Client):  # pragma: no cover
         return True
 
     @inspector(re_raise=False, no_raise_return=False)
-    async def check_connection_availability(self, handle_ping_pong: bool) -> bool:
+    async def check_connection_availability(self, *, handle_ping_pong: bool) -> bool:
         """Send ping to the backend to generate PONG event."""
         if handle_ping_pong and self.supports_ping_pong:
             self._ping_pong_cache.handle_send_ping(ping_ts=datetime.now())
         return True
 
     @inspector
-    async def execute_program(self, pid: str) -> bool:
+    async def execute_program(self, *, pid: str) -> bool:
         """Execute a program on the backend."""
         return True
 
     @inspector
-    async def set_program_state(self, pid: str, state: bool) -> bool:
+    async def set_program_state(self, *, pid: str, state: bool) -> bool:
         """Set the program state on the backend."""
         return True
 
     @inspector(measure_performance=True)
-    async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
+    async def set_system_variable(self, *, legacy_name: str, value: Any) -> bool:
         """Set a system variable on the backend."""
         return True
 
     @inspector
-    async def delete_system_variable(self, name: str) -> bool:
+    async def delete_system_variable(self, *, name: str) -> bool:
         """Delete a system variable from the backend."""
         return True
 
     @inspector
-    async def get_system_variable(self, name: str) -> str:
+    async def get_system_variable(self, *, name: str) -> str:
         """Get single system variable from the backend."""
         return "Empty"
 
     @inspector(re_raise=False)
     async def get_all_system_variables(
-        self, markers: tuple[DescriptionMarker | str, ...]
+        self, *, markers: tuple[DescriptionMarker | str, ...]
     ) -> tuple[SystemVariableData, ...]:
         """Get all system variables from the backend."""
         return ()
 
     @inspector(re_raise=False)
-    async def get_all_programs(self, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...]:
+    async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...]:
         """Get all programs, if available."""
         return ()
 
@@ -203,6 +203,7 @@ class ClientLocal(Client):  # pragma: no cover
     @inspector(log_level=logging.NOTSET)
     async def get_value(
         self,
+        *,
         channel_address: str,
         paramset_key: ParamsetKey,
         parameter: str,
@@ -214,6 +215,7 @@ class ClientLocal(Client):  # pragma: no cover
     @inspector(re_raise=False, no_raise_return=set())
     async def set_value(
         self,
+        *,
         channel_address: str,
         paramset_key: ParamsetKey,
         parameter: str,
@@ -228,12 +230,15 @@ class ClientLocal(Client):  # pragma: no cover
             channel_address=channel_address, parameter=parameter, value=value
         )
         # fire an event to fake the state change for a simple parameter
-        await self.central.data_point_event(self.interface_id, channel_address, parameter, value)
+        await self.central.data_point_event(
+            interface_id=self.interface_id, channel_address=channel_address, parameter=parameter, value=value
+        )
         return result
 
     @inspector
     async def get_paramset(
         self,
+        *,
         address: str,
         paramset_key: ParamsetKey | str,
         call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
@@ -247,7 +252,7 @@ class ClientLocal(Client):  # pragma: no cover
         return {}
 
     async def _get_paramset_description(
-        self, address: str, paramset_key: ParamsetKey
+        self, *, address: str, paramset_key: ParamsetKey
     ) -> dict[str, ParameterData] | None:
         """Get paramset description from the backend."""
         if not self._local_resources:
@@ -275,6 +280,7 @@ class ClientLocal(Client):  # pragma: no cover
     @inspector(measure_performance=True)
     async def put_paramset(
         self,
+        *,
         channel_address: str,
         paramset_key_or_link_address: ParamsetKey | str,
         values: Any,
@@ -300,11 +306,17 @@ class ClientLocal(Client):  # pragma: no cover
 
         # fire an event to fake the state change for the content of a paramset
         for parameter in values:
-            await self.central.data_point_event(self.interface_id, channel_address, parameter, values[parameter])
+            await self.central.data_point_event(
+                interface_id=self.interface_id,
+                channel_address=channel_address,
+                parameter=parameter,
+                value=values[parameter],
+            )
         return result
 
     async def _load_all_json_files(
         self,
+        *,
         anchor: str,
         resource: str,
         include_list: list[str] | None = None,
@@ -324,7 +336,7 @@ class ClientLocal(Client):  # pragma: no cover
                 result.append(file_content)
         return result
 
-    async def _load_json_file(self, anchor: str, resource: str, filename: str) -> Any | None:
+    async def _load_json_file(self, *, anchor: str, resource: str, filename: str) -> Any | None:
         """Load json file from disk into dict."""
         package_path = str(importlib.resources.files(anchor))