aiohomematic 2025.10.22__py3-none-any.whl → 2025.10.25__py3-none-any.whl

aiohomematic/central/__init__.py

@@ -251,7 +251,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         # e.g. DEVICES_CREATED, HUB_REFRESHED
         self._backend_system_callbacks: Final[set[Callable]] = set()
         # Signature: (interface_id, channel_address, parameter, value)
-        # Re-Fired events from the backend for parameter updates
+        # Re-emitted events from the backend for parameter updates
         self._backend_parameter_callbacks: Final[set[Callable]] = set()
         # Signature: (event_type, event_data)
         # Events like INTERFACE, KEYPRESS, ...
@@ -454,7 +454,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
     def remove_sysvar_data_point(self, *, vid: str) -> None:
         """Remove a sysvar data_point."""
         if (sysvar_dp := self.get_sysvar_data_point(vid=vid)) is not None:
-            sysvar_dp.fire_device_removed_callback()
+            sysvar_dp.emit_device_removed_event()
             del self._sysvar_data_points[vid]
             if sysvar_dp.state_path in self._sysvar_data_point_event_subscriptions:
                 del self._sysvar_data_point_event_subscriptions[sysvar_dp.state_path]
@@ -466,8 +466,8 @@ class CentralUnit(LogContextMixin, PayloadMixin):
     def remove_program_button(self, *, pid: str) -> None:
         """Remove a program button."""
         if (program_dp := self.get_program_data_point(pid=pid)) is not None:
-            program_dp.button.fire_device_removed_callback()
-            program_dp.switch.fire_device_removed_callback()
+            program_dp.button.emit_device_removed_event()
+            program_dp.switch.emit_device_removed_event()
             del self._program_data_points[pid]
 
     def identify_channel(self, *, text: str) -> Channel | None:
@@ -532,7 +532,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 self._xml_rpc_server = xml_rpc_server
                 self._listen_port_xml_rpc = xml_rpc_server.listen_port
                 self._xml_rpc_server.add_central(central=self)
-        except OSError as oserr:
+        except OSError as oserr:  # pragma: no cover - environment/OS-specific socket binding failures are not reliably reproducible in CI
             self._state = CentralUnitState.STOPPED_BY_ERROR
             raise AioHomematicException(
                 f"START: Failed to start central unit {self.name}: {extract_exc_args(exc=oserr)}"
@@ -763,8 +763,8 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 )
                 self._clients[client.interface_id] = client
                 return True
-        except BaseHomematicException as bhexc:
-            self.fire_interface_event(
+        except BaseHomematicException as bhexc:  # pragma: no cover - deterministic simulation of client creation failures would require the full client/proxy stack and network timing; keeping this defensive log-and-state branch untested to avoid brittle CI
+            self.emit_interface_event(
                 interface_id=interface_config.interface_id,
                 interface_event_type=InterfaceEventType.PROXY,
                 data={EventKey.AVAILABLE: False},
@@ -803,14 +803,14 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         await self._hub.fetch_sysvar_data(scheduled=True)
 
     @loop_check
-    def fire_interface_event(
+    def emit_interface_event(
         self,
         *,
         interface_id: str,
         interface_event_type: InterfaceEventType,
         data: dict[str, Any],
     ) -> None:
-        """Fire an event about the interface status."""
+        """Emit an event about the interface status."""
         data = data or {}
         event_data: dict[str, Any] = {
             EventKey.INTERFACE_ID: interface_id,
@@ -818,7 +818,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             EventKey.DATA: data,
         }
 
-        self.fire_homematic_callback(
+        self.emit_homematic_callback(
             event_type=EventType.INTERFACE,
             event_data=cast(dict[EventKey, Any], INTERFACE_EVENT_SCHEMA(event_data)),
         )
@@ -1019,7 +1019,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                         interface_id=interface_id,
                         device_address=device_address,
                     )
-                except Exception as exc:  # pragma: no cover
+                except Exception as exc:
                     _LOGGER.error(
                         "CREATE_DEVICES failed: %s [%s] Unable to create device: %s, %s",
                         type(exc).__name__,
@@ -1034,7 +1034,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                         await device.load_value_cache()
                         new_devices.add(device)
                         self._devices[device_address] = device
-                except Exception as exc:  # pragma: no cover
+                except Exception as exc:
                     _LOGGER.error(
                         "CREATE_DEVICES failed: %s [%s] Unable to create data points: %s, %s",
                         type(exc).__name__,
@@ -1047,7 +1047,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         if new_devices:
             new_dps = _get_new_data_points(new_devices=new_devices)
             new_channel_events = _get_new_channel_events(new_devices=new_devices)
-            self.fire_backend_system_callback(
+            self.emit_backend_system_callback(
                 system_event=BackendSystemEvent.DEVICES_CREATED,
                 new_data_points=new_dps,
                 new_channel_events=new_channel_events,
@@ -1157,7 +1157,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                     )
                 )
             ):
-                self.fire_backend_system_callback(
+                self.emit_backend_system_callback(
                     system_event=BackendSystemEvent.DEVICES_DELAYED,
                     new_addresses=new_addresses,
                     interface_id=interface_id,
@@ -1281,7 +1281,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 for callback_handler in self._data_point_key_event_subscriptions[dpk]:
                     if callable(callback_handler):
                         await callback_handler(value=value, received_at=received_at)
-            except RuntimeError as rterr:  # pragma: no cover
+            except RuntimeError as rterr:
                 _LOGGER_EVENT.debug(
                     "EVENT: RuntimeError [%s]. Failed to call callback for: %s, %s, %s",
                     extract_exc_args(exc=rterr),
@@ -1289,7 +1289,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                     channel_address,
                     parameter,
                 )
-            except Exception as exc:  # pragma: no cover
+            except Exception as exc:
                 _LOGGER_EVENT.warning(
                     "EVENT failed: Unable to call callback for: %s, %s, %s, %s",
                     interface_id,
@@ -1331,10 +1331,10 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 if callable(callback_handler):
                     received_at = datetime.now()
                     self._looper.create_task(
-                        target=callback_handler(value=value, received_at=received_at),
+                        target=lambda: callback_handler(value=value, received_at=received_at),
                         name=f"sysvar-data-point-event-{state_path}",
                     )
-            except RuntimeError as rterr:  # pragma: no cover
+            except RuntimeError as rterr:
                 _LOGGER_EVENT.debug(
                     "EVENT: RuntimeError [%s]. Failed to call callback for: %s",
                     extract_exc_args(exc=rterr),
@@ -1659,9 +1659,9 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             self._homematic_callbacks.remove(cb)
 
     @loop_check
-    def fire_homematic_callback(self, *, event_type: EventType, event_data: dict[EventKey, str]) -> None:
+    def emit_homematic_callback(self, *, event_type: EventType, event_data: dict[EventKey, str]) -> None:
         """
-        Fire homematic_callback in central.
+        Emit homematic_callback in central.
 
         # Events like INTERFACE, KEYPRESS, ...
         """
@@ -1670,7 +1670,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 callback_handler(event_type=event_type, event_data=event_data)
             except Exception as exc:
                 _LOGGER.error(
-                    "FIRE_HOMEMATIC_CALLBACK: Unable to call handler: %s",
+                    "EMIT_HOMEMATIC_CALLBACK: Unable to call handler: %s",
                     extract_exc_args(exc=exc),
                 )
 
@@ -1687,13 +1687,13 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             self._backend_parameter_callbacks.remove(cb)
 
     @loop_check
-    def fire_backend_parameter_callback(
+    def emit_backend_parameter_callback(
         self, *, interface_id: str, channel_address: str, parameter: str, value: Any
     ) -> None:
         """
-        Fire backend_parameter callback in central.
+        Emit backend_parameter callback in central.
 
-        Re-Fired events from the backend for parameter updates.
+        Re-emitted events from the backend for parameter updates.
         """
         for callback_handler in self._backend_parameter_callbacks:
             try:
@@ -1702,7 +1702,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 )
             except Exception as exc:
                 _LOGGER.error(
-                    "FIRE_BACKEND_PARAMETER_CALLBACK: Unable to call handler: %s",
+                    "EMIT_BACKEND_PARAMETER_CALLBACK: Unable to call handler: %s",
                     extract_exc_args(exc=exc),
                 )
 
@@ -1719,9 +1719,9 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             self._backend_system_callbacks.remove(cb)
 
     @loop_check
-    def fire_backend_system_callback(self, *, system_event: BackendSystemEvent, **kwargs: Any) -> None:
+    def emit_backend_system_callback(self, *, system_event: BackendSystemEvent, **kwargs: Any) -> None:
         """
-        Fire system_event callback in central.
+        Emit system_event callback in central.
 
         e.g. DEVICES_CREATED, HUB_REFRESHED
         """
@@ -1730,7 +1730,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 callback_handler(system_event=system_event, **kwargs)
             except Exception as exc:
                 _LOGGER.error(
-                    "FIRE_BACKEND_SYSTEM_CALLBACK: Unable to call handler: %s",
+                    "EMIT_BACKEND_SYSTEM_CALLBACK: Unable to call handler: %s",
                     extract_exc_args(exc=exc),
                 )
 
@@ -2125,7 +2125,7 @@ class CentralConfig:
         try:
             self.check_config()
             return CentralUnit(central_config=self)
-        except BaseHomematicException as bhexc:
+        except BaseHomematicException as bhexc:  # pragma: no cover
             raise AioHomematicException(
                 f"CREATE_CENTRAL: Not able to create a central: : {extract_exc_args(exc=bhexc)}"
             ) from bhexc

aiohomematic/central/decorators.py

@@ -52,7 +52,7 @@ def callback_backend_system(system_event: BackendSystemEvent) -> Callable:
                     central = unit.get_central(interface_id=str(args[1]))
                 if central:
                     central.looper.create_task(
-                        target=_exec_backend_system_callback(*args, **kwargs),
+                        target=lambda: _exec_backend_system_callback(*args, **kwargs),
                         name="wrapper_backend_system_callback",
                     )
             except Exception as exc:
@@ -72,7 +72,7 @@ def callback_backend_system(system_event: BackendSystemEvent) -> Callable:
                 interface_id: str = args[0] if len(args) > 0 else str(kwargs[_INTERFACE_ID])
                 if client := hmcl.get_client(interface_id=interface_id):
                     client.modified_at = datetime.now()
-                    client.central.fire_backend_system_callback(system_event=system_event, **kwargs)
+                    client.central.emit_backend_system_callback(system_event=system_event, **kwargs)
             except Exception as exc:  # pragma: no cover
                 _LOGGER.warning(
                     "EXEC_BACKEND_SYSTEM_CALLBACK failed: Unable to reduce kwargs for backend_system_callback"
@@ -109,7 +109,7 @@ def callback_event[**P, R](func: Callable[P, R]) -> Callable:
 
             if client := hmcl.get_client(interface_id=interface_id):
                 client.modified_at = datetime.now()
-                client.central.fire_backend_parameter_callback(
+                client.central.emit_backend_parameter_callback(
                     interface_id=interface_id, channel_address=channel_address, parameter=parameter, value=value
                 )
         except Exception as exc:  # pragma: no cover
@@ -123,7 +123,7 @@ def callback_event[**P, R](func: Callable[P, R]) -> Callable:
             unit = args[0]
             if isinstance(unit, hmcu.CentralUnit):
                 unit.looper.create_task(
-                    target=_async_wrap_sync(_exec_event_callback, *args, **kwargs),
+                    target=lambda: _async_wrap_sync(_exec_event_callback, *args, **kwargs),
                     name="wrapper_event_callback",
                 )
                 return

aiohomematic/client/__init__.py

@@ -336,7 +336,7 @@ class Client(ABC, LogContextMixin):
                 "available" if available else "unavailable",
                 self.interface_id,
             )
-        self.central.fire_interface_event(
+        self.central.emit_interface_event(
             interface_id=self.interface_id,
             interface_event_type=InterfaceEventType.PROXY,
             data={EventKey.AVAILABLE: available},
@@ -406,7 +406,7 @@ class Client(ABC, LogContextMixin):
         ) is not None:
             if (seconds_since_last_event := (datetime.now() - last_events_dt).total_seconds()) > CALLBACK_WARN_INTERVAL:
                 if self._is_callback_alive:
-                    self.central.fire_interface_event(
+                    self.central.emit_interface_event(
                         interface_id=self.interface_id,
                         interface_event_type=InterfaceEventType.CALLBACK,
                         data={
@@ -423,7 +423,7 @@ class Client(ABC, LogContextMixin):
                 return False
 
             if not self._is_callback_alive:
-                self.central.fire_interface_event(
+                self.central.emit_interface_event(
                     interface_id=self.interface_id,
                     interface_event_type=InterfaceEventType.CALLBACK,
                     data={EventKey.AVAILABLE: True},
@@ -437,13 +437,13 @@ class Client(ABC, LogContextMixin):
         """Send ping to the backend to generate PONG event."""
 
     @inspector
-    async def execute_program(self, *, pid: str) -> bool:
+    async def execute_program(self, *, pid: str) -> bool:  # pragma: no cover
         """Execute a program on the backend."""
         _LOGGER.debug("EXECUTE_PROGRAM: not usable for %s.", self.interface_id)
         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:  # pragma: no cover
         """Set the program state on the backend."""
         _LOGGER.debug("SET_PROGRAM_STATE: not usable for %s.", self.interface_id)
         return True
@@ -471,19 +471,21 @@ class Client(ABC, LogContextMixin):
         """Get all system variables from the backend."""
 
     @inspector(re_raise=False)
-    async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...] | None:
+    async def get_all_programs(
+        self, *, markers: tuple[DescriptionMarker | str, ...]
+    ) -> tuple[ProgramData, ...] | None:  # pragma: no cover
         """Get all programs, if available."""
         _LOGGER.debug("GET_ALL_PROGRAMS: not usable for %s.", self.interface_id)
         return None
 
     @inspector(re_raise=False, no_raise_return={})
-    async def get_all_rooms(self) -> dict[str, set[str]]:
+    async def get_all_rooms(self) -> dict[str, set[str]]:  # pragma: no cover
         """Get all rooms, if available."""
         _LOGGER.debug("GET_ALL_ROOMS: not usable for %s.", self.interface_id)
         return {}
 
     @inspector(re_raise=False, no_raise_return={})
-    async def get_all_functions(self) -> dict[str, set[str]]:
+    async def get_all_functions(self) -> dict[str, set[str]]:  # pragma: no cover
         """Get all functions, if available."""
         _LOGGER.debug("GET_ALL_FUNCTIONS: not usable for %s.", self.interface_id)
         return {}
@@ -767,7 +769,7 @@ class Client(ABC, LogContextMixin):
                 call_source,
             )
             return cast(dict[str, Any], await self._proxy_read.getParamset(address, paramset_key))
-        except BaseHomematicException as bhexc:
+        except BaseHomematicException as bhexc:  # pragma: no cover
             raise ClientException(
                 f"GET_PARAMSET failed with for {address}/{paramset_key}: {extract_exc_args(exc=bhexc)}"
             ) from bhexc
@@ -1033,7 +1035,7 @@ class Client(ABC, LogContextMixin):
         """List devices of the backend."""
         try:
             return tuple(await self._proxy_read.listDevices())
-        except BaseHomematicException as bhexc:
+        except BaseHomematicException as bhexc:  # pragma: no cover
             _LOGGER.debug(
                 "LIST_DEVICES failed: %s [%s]",
                 bhexc.name,
@@ -1145,7 +1147,7 @@ class ClientCCU(Client):
                 self.central.data_cache.add_data(interface=self.interface, all_device_data=all_device_data)
                 return
         except ClientException:
-            self.central.fire_interface_event(
+            self.central.emit_interface_event(
                 interface_id=self.interface_id,
                 interface_event_type=InterfaceEventType.FETCH_DATA,
                 data={EventKey.AVAILABLE: False},
@@ -1168,8 +1170,8 @@ class ClientCCU(Client):
                     if handle_ping_pong
                     else self.interface_id
                 )
-                self._ping_pong_cache.handle_send_ping(ping_ts=dt_now)
                 await self._proxy.ping(callerId)
+                self._ping_pong_cache.handle_send_ping(ping_ts=dt_now)
             elif not self._is_initialized:
                 await self._proxy.ping(self.interface_id)
             self.modified_at = dt_now
@@ -1545,7 +1547,7 @@ class ClientHomegear(ClientCCU):
                     address=address,
                     name=await self._proxy_read.getMetadata(address, _NAME),
                 )
-            except BaseHomematicException as bhexc:
+            except BaseHomematicException as bhexc:  # pragma: no cover
                 _LOGGER.warning(
                     "%s [%s] Failed to fetch name for device %s",
                     bhexc.name,
@@ -1559,7 +1561,7 @@ class ClientHomegear(ClientCCU):
         try:
             await self._proxy.clientServerInitialized(self.interface_id)
             self.modified_at = datetime.now()
-        except BaseHomematicException as bhexc:
+        except BaseHomematicException as bhexc:  # pragma: no cover
             _LOGGER.debug(
                 "CHECK_CONNECTION_AVAILABILITY failed: %s [%s]",
                 bhexc.name,
@@ -1661,7 +1663,7 @@ class ClientConfig:
             raise NoConnectionException(f"No connection to {self.interface_id}")
         except BaseHomematicException:
             raise
-        except Exception as exc:
+        except Exception as exc:  # pragma: no cover
             raise NoConnectionException(f"Unable to connect {extract_exc_args(exc=exc)}.") from exc
 
     async def _get_version(self) -> str:
@@ -1673,7 +1675,7 @@ class ClientConfig:
             if (methods := check_proxy.supported_methods) and "getVersion" in methods:
                 # BidCos-Wired does not support getVersion()
                 return cast(str, await check_proxy.getVersion())
-        except Exception as exc:
+        except Exception as exc:  # pragma: no cover
             raise NoConnectionException(f"Unable to connect {extract_exc_args(exc=exc)}.") from exc
         return "0"
 

aiohomematic/client/json_rpc.py

@@ -339,6 +339,11 @@ class AioJsonRpcAioHttpClient(LogContextMixin):
         keep_session: bool = True,
     ) -> dict[str, Any] | Any:
         """Reusable JSON-RPC POST_SCRIPT function."""
+        # Load and validate script first to avoid any network when script is missing
+        if (script := await self._get_script(script_name=script_name)) is None:
+            raise ClientException(f"Script file for {script_name} does not exist")
+
+        # Prepare session only after we know we have a script to run
         if keep_session:
             await self._login_or_renew()
             session_id = self._session_id
@@ -351,9 +356,6 @@ class AioJsonRpcAioHttpClient(LogContextMixin):
         if self._supported_methods is None:
             await self._check_supported_methods()
 
-        if (script := await self._get_script(script_name=script_name)) is None:
-            raise ClientException(f"Script file for {script_name} does not exist")
-
         if extra_params:
             for variable, value in extra_params.items():
                 script = script.replace(f"##{variable}##", value)
@@ -384,9 +386,12 @@ class AioJsonRpcAioHttpClient(LogContextMixin):
         def _load_script(script_name: str) -> str | None:
             """Load script from file system."""
             script_file = os.path.join(Path(__file__).resolve().parent, REGA_SCRIPT_PATH, script_name)
-            if script := Path(script_file).read_text(encoding=UTF_8):
-                self._script_cache[script_name] = script
-                return script
+            try:
+                if script := Path(script_file).read_text(encoding=UTF_8):
+                    self._script_cache[script_name] = script
+                    return script
+            except FileNotFoundError:
+                return None
             return None
 
         return await self._looper.async_add_executor_job(_load_script, script_name, name=f"load_script-{script_name}")

aiohomematic/client/rpc_proxy.py

@@ -216,7 +216,7 @@ class AioXmlRpcProxy(BaseRpcProxy, xmlrpc.client.ServerProxy):
         except BaseHomematicException as bhe:
             self._record_session(method=args[0], params=args[1:], exc=bhe)
             raise
-        except SSLError as sslerr:
+        except SSLError as sslerr:  # pragma: no cover - SSL handshake/cert errors are OS/OpenSSL dependent and not reliably reproducible in CI
             message = f"SSLError on {self._interface_id}: {extract_exc_args(exc=sslerr)}"
             level = logging.ERROR
             if sslerr.args[0] in _SSL_ERROR_CODES:
@@ -237,7 +237,7 @@ class AioXmlRpcProxy(BaseRpcProxy, xmlrpc.client.ServerProxy):
                 log_context=self.log_context,
             )
             raise NoConnectionException(message) from sslerr
-        except OSError as oserr:
+        except OSError as oserr:  # pragma: no cover - Network/socket errno differences are platform/environment specific; simulating reliably in CI would be flaky
             message = f"OSError on {self._interface_id}: {extract_exc_args(exc=oserr)}"
             level = (
                 logging.ERROR

aiohomematic/const.py

@@ -19,7 +19,7 @@ import sys
 from types import MappingProxyType
 from typing import Any, Final, NamedTuple, Required, TypeAlias, TypedDict
 
-VERSION: Final = "2025.10.22"
+VERSION: Final = "2025.10.25"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (

aiohomematic/hmcli.py

@@ -13,6 +13,7 @@ exposes the 'main' entrypoint for invocation. All other names are internal.
 from __future__ import annotations
 
 import argparse
+import json
 import sys
 from typing import Any
 from xmlrpc.client import ServerProxy
@@ -124,11 +125,15 @@ def main() -> None:
 
     try:
         if args.paramset_key == ParamsetKey.VALUES and args.value is None:
-            proxy.getValue(args.address, args.parameter)
+            result = proxy.getValue(args.address, args.parameter)
             if args.json:
-                pass
+                print(
+                    json.dumps(
+                        {"address": args.address, "parameter": args.parameter, "value": result}, ensure_ascii=False
+                    )
+                )
             else:
-                pass
+                print(result)
             sys.exit(0)
         elif args.paramset_key == ParamsetKey.VALUES and args.value:
             value: Any
@@ -144,13 +149,22 @@ def main() -> None:
             sys.exit(0)
         elif args.paramset_key == ParamsetKey.MASTER and args.value is None:
             paramset: dict[str, Any] | None
-            if (paramset := proxy.getParamset(args.address, args.paramset_key)) and paramset.get(  # type: ignore[assignment]
-                args.parameter
-            ):
+            if (paramset := proxy.getParamset(args.address, args.paramset_key)) and (args.parameter in paramset):  # type: ignore[assignment]
+                result = paramset[args.parameter]
                 if args.json:
-                    pass
+                    print(
+                        json.dumps(
+                            {
+                                "address": args.address,
+                                "paramset_key": args.paramset_key,
+                                "parameter": args.parameter,
+                                "value": result,
+                            },
+                            ensure_ascii=False,
+                        )
+                    )
                 else:
-                    pass
+                    print(result)
             sys.exit(0)
         elif args.paramset_key == ParamsetKey.MASTER and args.value:
             if args.type == "int":
@@ -163,7 +177,8 @@ def main() -> None:
                 value = args.value
             proxy.putParamset(args.address, args.paramset_key, {args.parameter: value})
             sys.exit(0)
-    except Exception:
+    except Exception as ex:
+        print(str(ex), file=sys.stderr)
         sys.exit(1)
 
 

aiohomematic/model/calculated/data_point.py

@@ -99,9 +99,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         if generic_data_point := self._channel.get_generic_data_point(parameter=parameter, paramset_key=paramset_key):
             self._data_points.append(generic_data_point)
             self._unregister_callbacks.append(
-                generic_data_point.register_internal_data_point_updated_callback(
-                    cb=self.fire_data_point_updated_callback
-                )
+                generic_data_point.register_internal_data_point_updated_callback(cb=self.emit_data_point_updated_event)
             )
             return cast(data_point_type, generic_data_point)  # type: ignore[valid-type]
         return cast(
@@ -123,9 +121,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         ):
             self._data_points.append(generic_data_point)
             self._unregister_callbacks.append(
-                generic_data_point.register_internal_data_point_updated_callback(
-                    cb=self.fire_data_point_updated_callback
-                )
+                generic_data_point.register_internal_data_point_updated_callback(cb=self.emit_data_point_updated_event)
             )
             return cast(data_point_type, generic_data_point)  # type: ignore[valid-type]
         return cast(
@@ -296,7 +292,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         """Init the data point values."""
         for dp in self._readable_data_points:
             await dp.load_data_point_value(call_source=call_source, direct_call=direct_call)
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def is_state_change(self, **kwargs: Any) -> bool:
         """
@@ -310,9 +306,9 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         return False
 
     @property
-    def _should_fire_data_point_updated_callback(self) -> bool:
+    def _should_emit_data_point_updated_callback(self) -> bool:
         """Check if a data point has been updated or refreshed."""
-        if self.fired_event_recently:  # pylint: disable=using-constant-test
+        if self.emitted_event_recently:  # pylint: disable=using-constant-test
             return False
 
         if (relevant_values_data_point := self._relevant_values_data_points) is not None and len(
@@ -320,7 +316,7 @@ class CalculatedDataPoint[ParameterT: GenericParameterType](BaseDataPoint):
         ) <= 1:
             return True
 
-        return all(dp.fired_event_recently for dp in relevant_values_data_point)
+        return all(dp.emitted_event_recently for dp in relevant_values_data_point)
 
     def _unregister_data_point_updated_callback(self, *, cb: Callable, custom_id: str) -> None:
         """Unregister update callback."""

aiohomematic/model/custom/data_point.py

@@ -188,7 +188,7 @@ class CustomDataPoint(BaseDataPoint):
         """Init the data point values."""
         for dp in self._readable_data_points:
             await dp.load_data_point_value(call_source=call_source, direct_call=direct_call)
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def is_state_change(self, **kwargs: Any) -> bool:
         """
@@ -268,7 +268,7 @@ class CustomDataPoint(BaseDataPoint):
             data_point.force_usage(forced_usage=DataPointUsage.NO_CREATE)
 
         self._unregister_callbacks.append(
-            data_point.register_internal_data_point_updated_callback(cb=self.fire_data_point_updated_callback)
+            data_point.register_internal_data_point_updated_callback(cb=self.emit_data_point_updated_event)
         )
         self._data_points[field] = data_point
 

aiohomematic/model/custom/definition.py

@@ -353,7 +353,7 @@ _CUSTOM_DATA_POINT_DEFINITION: Mapping[CDPD, Mapping[int | DeviceProfile, Any]]
                         Field.LEVEL: Parameter.LEVEL,
                         Field.CONCENTRATION: Parameter.CONCENTRATION,
                     },
-                    8: {
+                    8: {  # BWTH
                         Field.STATE: Parameter.STATE,
                     },
                 },
@@ -361,6 +361,9 @@ _CUSTOM_DATA_POINT_DEFINITION: Mapping[CDPD, Mapping[int | DeviceProfile, Any]]
                     7: {
                         Field.HEATING_VALVE_TYPE: Parameter.HEATING_VALVE_TYPE,
                     },
+                    -5: {  # WGTC
+                        Field.STATE: Parameter.STATE,
+                    },
                 },
             },
         },

aiohomematic/model/custom/light.py

@@ -352,7 +352,7 @@ class CustomDpColorDimmerEffect(CustomDpColorDimmer):
         "Slow color change",
         "Medium color change",
         "Fast color change",
-        "Campfire",
+        "Campemit",
         "Waterfall",
         "TV simulation",
     )

aiohomematic/model/data_point.py

@@ -143,7 +143,7 @@ class CallbackDataPoint(ABC, LogContextMixin):
         "_custom_id",
         "_data_point_updated_callbacks",
         "_device_removed_callbacks",
-        "_fired_event_at",
+        "_emitted_event_at",
         "_modified_at",
         "_path_data",
         "_refreshed_at",
@@ -163,7 +163,7 @@ class CallbackDataPoint(ABC, LogContextMixin):
         self._device_removed_callbacks: list[Callable] = []
         self._custom_id: str | None = None
         self._path_data = self._get_path_data()
-        self._fired_event_at: datetime = INIT_DATETIME
+        self._emitted_event_at: datetime = INIT_DATETIME
         self._modified_at: datetime = INIT_DATETIME
         self._refreshed_at: datetime = INIT_DATETIME
         self._signature: Final = self._get_signature()
@@ -191,16 +191,16 @@ class CallbackDataPoint(ABC, LogContextMixin):
         return self._custom_id
 
     @property
-    def fired_event_at(self) -> datetime:
-        """Return the data point updated fired an event at."""
-        return self._fired_event_at
+    def emitted_event_at(self) -> datetime:
+        """Return the data point updated emitted an event at."""
+        return self._emitted_event_at
 
     @state_property
-    def fired_event_recently(self) -> bool:
-        """Return the data point fired an event within 500 milliseconds."""
-        if self._fired_event_at == INIT_DATETIME:
+    def emitted_event_recently(self) -> bool:
+        """Return the data point emitted an event within 500 milliseconds."""
+        if self._emitted_event_at == INIT_DATETIME:
             return False
-        return (datetime.now() - self._fired_event_at).total_seconds() < 0.5
+        return (datetime.now() - self._emitted_event_at).total_seconds() < 0.5
 
     @classmethod
     def default_category(cls) -> DataPointCategory:
@@ -357,11 +357,11 @@ class CallbackDataPoint(ABC, LogContextMixin):
             self._device_removed_callbacks.remove(cb)
 
     @loop_check
-    def fire_data_point_updated_callback(self, **kwargs: Any) -> None:
+    def emit_data_point_updated_event(self, **kwargs: Any) -> None:
         """Do what is needed when the value of the data_point has been updated/refreshed."""
-        if not self._should_fire_data_point_updated_callback:
+        if not self._should_emit_data_point_updated_callback:
             return
-        self._fired_event_at = datetime.now()
+        self._emitted_event_at = datetime.now()
         for callback_handler, custom_id in self._data_point_updated_callbacks.items():
             try:
                 # Add the data_point reference once to kwargs to avoid per-callback writes.
@@ -369,19 +369,19 @@ class CallbackDataPoint(ABC, LogContextMixin):
                 kwargs[KWARGS_ARG_CUSTOM_ID] = custom_id
                 callback_handler(**kwargs)
             except Exception as exc:
-                _LOGGER.warning("FIRE_DATA_POINT_UPDATED_EVENT failed: %s", extract_exc_args(exc=exc))
+                _LOGGER.warning("EMIT_DATA_POINT_UPDATED_EVENT failed: %s", extract_exc_args(exc=exc))
 
     @loop_check
-    def fire_device_removed_callback(self) -> None:
+    def emit_device_removed_event(self) -> None:
         """Do what is needed when the data_point has been removed."""
         for callback_handler in self._device_removed_callbacks:
             try:
                 callback_handler()
             except Exception as exc:
-                _LOGGER.warning("FIRE_DEVICE_REMOVED_EVENT failed: %s", extract_exc_args(exc=exc))
+                _LOGGER.warning("EMIT_DEVICE_REMOVED_EVENT failed: %s", extract_exc_args(exc=exc))
 
     @property
-    def _should_fire_data_point_updated_callback(self) -> bool:
+    def _should_emit_data_point_updated_callback(self) -> bool:
         """Check if a data point has been updated or refreshed."""
         return True
 
@@ -895,7 +895,7 @@ class BaseParameterDataPoint[
         if value == NO_CACHE_ENTRY:
             if self.refreshed_at != INIT_DATETIME:
                 self._state_uncertain = True
-                self.fire_data_point_updated_callback()
+                self.emit_data_point_updated_event()
             return (old_value, None)  # type: ignore[return-value]
 
         new_value = self._convert_value(value=value)
@@ -906,7 +906,7 @@ class BaseParameterDataPoint[
             self._previous_value = old_value
             self._current_value = new_value
         self._state_uncertain = False
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
         return (old_value, new_value)
 
     def write_temporary_value(self, *, value: Any, write_at: datetime) -> None:
@@ -920,7 +920,7 @@ class BaseParameterDataPoint[
             self._set_temporary_modified_at(modified_at=write_at)
             self._temporary_value = temp_value
             self._state_uncertain = True
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def update_parameter_data(self) -> None:
         """Update parameter data."""

aiohomematic/model/device.py

@@ -598,7 +598,7 @@ class Device(LogContextMixin, PayloadMixin):
         if self._forced_availability != forced_availability:
             self._forced_availability = forced_availability
             for dp in self.generic_data_points:
-                dp.fire_data_point_updated_callback()
+                dp.emit_data_point_updated_event()
 
     @inspector
     async def export_device_definition(self) -> None:
@@ -674,17 +674,17 @@ class Device(LogContextMixin, PayloadMixin):
         await self._central.save_files(save_paramset_descriptions=True)
         for dp in self.generic_data_points:
             dp.update_parameter_data()
-        self.fire_device_updated_callback()
+        self.emit_device_updated_callback()
 
     @loop_check
-    def fire_device_updated_callback(self) -> None:
+    def emit_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()
             except Exception as exc:
-                _LOGGER.warning("FIRE_DEVICE_UPDATED failed: %s", extract_exc_args(exc=exc))
+                _LOGGER.warning("EMIT_DEVICE_UPDATED failed: %s", extract_exc_args(exc=exc))
 
     def __str__(self) -> str:
         """Provide some useful information."""
@@ -963,7 +963,7 @@ class Channel(LogContextMixin, PayloadMixin):
             self._calculated_data_points[data_point.dpk] = data_point
         if isinstance(data_point, GenericDataPoint):
             self._generic_data_points[data_point.dpk] = data_point
-            self._device.register_device_updated_callback(cb=data_point.fire_data_point_updated_callback)
+            self._device.register_device_updated_callback(cb=data_point.emit_data_point_updated_event)
         if isinstance(data_point, hmce.CustomDataPoint):
             self._custom_data_point = data_point
         if isinstance(data_point, GenericEvent):
@@ -977,12 +977,12 @@ class Channel(LogContextMixin, PayloadMixin):
             del self._calculated_data_points[data_point.dpk]
         if isinstance(data_point, GenericDataPoint):
             del self._generic_data_points[data_point.dpk]
-            self._device.unregister_device_updated_callback(cb=data_point.fire_data_point_updated_callback)
+            self._device.unregister_device_updated_callback(cb=data_point.emit_data_point_updated_event)
         if isinstance(data_point, hmce.CustomDataPoint):
             self._custom_data_point = None
         if isinstance(data_point, GenericEvent):
             del self._generic_events[data_point.dpk]
-        data_point.fire_device_removed_callback()
+        data_point.emit_device_removed_event()
 
     def remove(self) -> None:
         """Remove data points from collections and central."""

aiohomematic/model/event.py

@@ -8,7 +8,7 @@ button presses, device errors, and impulse notifications to applications.
 
 Included classes:
 - GenericEvent: Base event that integrates with the common data point API
-  (category, usage, names/paths, callbacks) and provides fire_event handling.
+  (category, usage, names/paths, callbacks) and provides emit_event handling.
 - ClickEvent: Represents key press events (EventType.KEYPRESS).
 - DeviceErrorEvent: Represents device error signaling with special value change
   semantics before emitting an event (EventType.DEVICE_ERROR).
@@ -102,14 +102,14 @@ class GenericEvent(BaseParameterDataPoint[Any, Any]):
     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.emit_data_point_updated_event()
         self._set_modified_at(modified_at=received_at)
-        self.fire_event(value=value)
+        self.emit_event(value=value)
 
     @loop_check
-    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))
+    def emit_event(self, *, value: Any) -> None:
+        """Do what is needed to emit an event."""
+        self._central.emit_homematic_callback(event_type=self.event_type, event_data=self.get_event_data(value=value))
 
     def _get_data_point_name(self) -> DataPointNameData:
         """Create the name for the data_point."""
@@ -149,7 +149,7 @@ class DeviceErrorEvent(GenericEvent):
             isinstance(new_value, int)
             and ((old_value is None and new_value > 0) or (isinstance(old_value, int) and old_value != new_value))
         ):
-            self.fire_event(value=new_value)
+            self.emit_event(value=new_value)
 
 
 class ImpulseEvent(GenericEvent):

aiohomematic/model/generic/data_point.py

@@ -83,8 +83,8 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             Parameter.UN_REACH,
             Parameter.STICKY_UN_REACH,
         ):
-            self._device.fire_device_updated_callback()
-            self._central.fire_homematic_callback(
+            self._device.emit_device_updated_callback()
+            self._central.emit_homematic_callback(
                 event_type=EventType.DEVICE_AVAILABILITY,
                 event_data=self.get_event_data(value=new_value),
             )

aiohomematic/model/hub/__init__.py

@@ -204,7 +204,7 @@ class Hub:
                 new_programs.append(program_dp.switch)
 
         if new_programs:
-            self._central.fire_backend_system_callback(
+            self._central.emit_backend_system_callback(
                 system_event=BackendSystemEvent.HUB_REFRESHED,
                 new_data_points=_get_new_hub_data_points(data_points=new_programs),
             )
@@ -240,7 +240,7 @@ class Hub:
                 new_sysvars.append(self._create_system_variable(data=sysvar))
 
         if new_sysvars:
-            self._central.fire_backend_system_callback(
+            self._central.emit_backend_system_callback(
                 system_event=BackendSystemEvent.HUB_REFRESHED,
                 new_data_points=_get_new_hub_data_points(data_points=new_sysvars),
             )

aiohomematic/model/hub/data_point.py

@@ -230,7 +230,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
             self._previous_value = old_value
             self._current_value = new_value
         self._state_uncertain = False
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def _write_temporary_value(self, *, value: Any, write_at: datetime) -> None:
         """Update the temporary value of the data_point."""
@@ -243,7 +243,7 @@ class GenericSysvarDataPoint(GenericHubDataPoint):
             self._set_temporary_modified_at(modified_at=write_at)
             self._temporary_value = temp_value
             self._state_uncertain = True
-        self.fire_data_point_updated_callback()
+        self.emit_data_point_updated_event()
 
     def _convert_value(self, *, old_value: Any, new_value: Any) -> Any:
         """Convert to value to SYSVAR_TYPE."""
@@ -333,7 +333,7 @@ class GenericProgramDataPoint(GenericHubDataPoint):
             self._last_execute_time = data.last_execute_time
             do_update = True
         if do_update:
-            self.fire_data_point_updated_callback()
+            self.emit_data_point_updated_event()
 
     def _get_path_data(self) -> PathData:
         """Return the path data of the data_point."""

aiohomematic/property_decorators.py

@@ -117,7 +117,7 @@ class _GenericProperty[GETTER, SETTER](property):
             kind=self.kind,
             cached=self._cached,
             log_context=self.log_context,
-        )  # pragma: no cover
+        )
 
     def setter(self, fset: Callable[[Any, SETTER], None], /) -> _GenericProperty:
         """Return generic setter."""
@@ -155,7 +155,7 @@ class _GenericProperty[GETTER, SETTER](property):
             return cast(GETTER, self)
 
         if (fget := self.fget) is None:
-            raise AttributeError("unreadable attribute")  # pragma: no cover
+            raise AttributeError("unreadable attribute")
 
         if not self._cached:
             return fget(instance)
@@ -194,7 +194,7 @@ class _GenericProperty[GETTER, SETTER](property):
                     delattr(instance, self._cache_attr)
 
         if self.fset is None:
-            raise AttributeError("can't set attribute")  # pragma: no cover
+            raise AttributeError("can't set attribute")
         self.fset(instance, value)
 
     def __delete__(self, instance: Any, /) -> None:
@@ -210,7 +210,7 @@ class _GenericProperty[GETTER, SETTER](property):
                     delattr(instance, self._cache_attr)
 
         if self.fdel is None:
-            raise AttributeError("can't delete attribute")  # pragma: no cover
+            raise AttributeError("can't delete attribute")
         self.fdel(instance)
 
 

aiohomematic/store/dynamic.py

@@ -416,7 +416,7 @@ class PingPongCache:
         # but always emit when crossing the high threshold.
         count = self._pending_pong_count
         if (count > self._allowed_delta) or (count % 2 == 0):
-            self._check_and_fire_pong_event(event_type=InterfaceEventType.PENDING_PONG)
+            self._check_and_emit_pong_event(event_type=InterfaceEventType.PENDING_PONG)
         _LOGGER.debug(
             "PING PONG CACHE: Increase pending PING count: %s - %i for ts: %s",
             self._interface_id,
@@ -430,7 +430,7 @@ class PingPongCache:
             self._pending_pongs.remove(pong_ts)
             self._cleanup_pending_pongs()
             count = self._pending_pong_count
-            self._check_and_fire_pong_event(event_type=InterfaceEventType.PENDING_PONG)
+            self._check_and_emit_pong_event(event_type=InterfaceEventType.PENDING_PONG)
             _LOGGER.debug(
                 "PING PONG CACHE: Reduce pending PING count: %s - %i for ts: %s",
                 self._interface_id,
@@ -441,7 +441,7 @@ class PingPongCache:
             self._unknown_pongs.add(pong_ts)
             self._cleanup_unknown_pongs()
             count = self._unknown_pong_count
-            self._check_and_fire_pong_event(event_type=InterfaceEventType.UNKNOWN_PONG)
+            self._check_and_emit_pong_event(event_type=InterfaceEventType.UNKNOWN_PONG)
             _LOGGER.debug(
                 "PING PONG CACHE: Increase unknown PONG count: %s - %i for ts: %s",
                 self._interface_id,
@@ -477,11 +477,12 @@ class PingPongCache:
                     up_pong_ts,
                 )
 
-    def _check_and_fire_pong_event(self, *, event_type: InterfaceEventType) -> None:
-        """Fire an event about the pong status."""
+    def _check_and_emit_pong_event(self, *, event_type: InterfaceEventType) -> None:
+        """Emit an event about the pong status."""
 
-        def _fire_event(mismatch_count: int) -> None:
-            self._central.fire_homematic_callback(
+        def _emit_event(mismatch_count: int) -> None:
+            """Emit event."""
+            self._central.emit_homematic_callback(
                 event_type=EventType.INTERFACE,
                 event_data=cast(
                     dict[EventKey, Any],
@@ -498,13 +499,19 @@ class PingPongCache:
                     ),
                 ),
             )
+            _LOGGER.debug(
+                "PING PONG CACHE: Emitting event %s for %s with mismatch_count: %i with %i acceptable",
+                event_type,
+                self._interface_id,
+                mismatch_count,
+                self._allowed_delta,
+            )
 
         if event_type == InterfaceEventType.PENDING_PONG:
             self._cleanup_pending_pongs()
-            count = self._pending_pong_count
-            if self._pending_pong_count > self._allowed_delta:
+            if (count := self._pending_pong_count) > self._allowed_delta:
                 # Emit interface event to inform subscribers about high pending pong count.
-                _fire_event(mismatch_count=count)
+                _emit_event(mismatch_count=count)
                 if self._pending_pong_logged is False:
                     _LOGGER.warning(
                         "Pending PONG mismatch: There is a mismatch between send ping events and received pong events for instance %s. "
@@ -519,16 +526,16 @@ class PingPongCache:
             # - If we previously logged a high state, emit a reset event (mismatch=0) exactly once.
             # - Otherwise, throttle emission to every second ping (even counts > 0) to avoid spamming.
             elif self._pending_pong_logged:
-                _fire_event(mismatch_count=0)
+                _emit_event(mismatch_count=0)
                 self._pending_pong_logged = False
             elif count > 0 and count % 2 == 0:
-                _fire_event(mismatch_count=count)
+                _emit_event(mismatch_count=count)
         elif event_type == InterfaceEventType.UNKNOWN_PONG:
             self._cleanup_unknown_pongs()
             count = self._unknown_pong_count
             if self._unknown_pong_count > self._allowed_delta:
                 # Emit interface event to inform subscribers about high unknown pong count.
-                _fire_event(mismatch_count=count)
+                _emit_event(mismatch_count=count)
                 if self._unknown_pong_logged is False:
                     _LOGGER.warning(
                         "Unknown PONG Mismatch: Your instance %s receives PONG events, that it hasn't send. "

aiohomematic/store/visibility.py

@@ -423,8 +423,7 @@ class ParameterVisibilityCache:
         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)
-        if dt_short_key is None and model_l not in cache_dict:
+        if (dt_short_key := cache_dict.get(model_l)) is None and model_l not in cache_dict:
             dt_short_key = next((k for k in mapping if model_l.startswith(k)), None)
             cache_dict[model_l] = dt_short_key
         return dt_short_key
@@ -486,7 +485,7 @@ class ParameterVisibilityCache:
                 return False
 
             if parameter in self._custom_un_ignore_complex[model_l][channel.no][ParamsetKey.MASTER]:
-                return False  # pragma: no cover
+                return False
 
             dt_short_key = self._resolve_prefix_key(
                 model_l=model_l,
@@ -545,7 +544,7 @@ class ParameterVisibilityCache:
         for ml, cno in search_matrix:
             if parameter in self._custom_un_ignore_complex[ml][cno][paramset_key]:
                 self._param_un_ignored_cache[cache_key] = True
-                return True  # pragma: no cover
+                return True
 
         # check if parameter is in _UN_IGNORE_PARAMETERS_BY_DEVICE
         result = bool(

{aiohomematic-2025.10.22.dist-info → aiohomematic-2025.10.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.22
+Version: 2025.10.25
 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>
@@ -15,10 +15,16 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.13.0
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12.0

{aiohomematic-2025.10.22.dist-info → aiohomematic-2025.10.25.dist-info}/RECORD

@@ -1,40 +1,40 @@
 aiohomematic/__init__.py,sha256=Uo9CIoil0Arl3GwtgMZAwM8jhcgoBKcZEgj8cXYlswY,2258
 aiohomematic/async_support.py,sha256=Fg6RLD7Irt1mTwXbLkfphJbfd7oU_Svhp23i3Bb4Q7k,8762
-aiohomematic/const.py,sha256=omyYHT1lCVMAju-lRA3nTU0yuX2C_vM8MuZ5K3ofstA,27482
+aiohomematic/const.py,sha256=qS6qjW8szpJYt1hudHJG7zokHp_PjoO1-u65Z5-TsXU,27482
 aiohomematic/context.py,sha256=hGE-iPcPt21dY-1MZar-Hyh9YaKL-VS42xjrulIVyRQ,429
 aiohomematic/converter.py,sha256=FiHU71M5RZ7N5FXJYh2CN14s63-PM-SHdb0cJ_CLx54,3602
 aiohomematic/decorators.py,sha256=cSW0aF3PzrW_qW6H0sjRNH9eqO8ysqhXZDgJ2OJTZM4,11038
 aiohomematic/exceptions.py,sha256=RLldRD4XY8iYuNYVdspCbbphGcKsximB7R5OL7cYKw0,5006
-aiohomematic/hmcli.py,sha256=_QZFKcfr_KJrdiyBRbhz0f8LZ95glD7LgJBmQc8cwog,4911
-aiohomematic/property_decorators.py,sha256=3Id1_rWIYnwyN_oSMgbh7XNKz9HPkGTC1CeS5ei04ZQ,17139
+aiohomematic/hmcli.py,sha256=E44gJYSRiP0HGNHRD3LwWiYpIHpiBvJTsKcavVFIS8g,5635
+aiohomematic/property_decorators.py,sha256=v8O_6hW5plpD1-Cmhbb-6t_RfAl8wD4TskWt777t8rY,17059
 aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiohomematic/support.py,sha256=F8jiuRgw3Dn7v2kPBvFTHFGI4nJzybd3eQIQEK4Y6XI,21056
 aiohomematic/validator.py,sha256=qX5janicu4jLrAVzKoyWgXe1XU4EOjk5-QhNFL4awTQ,3541
-aiohomematic/central/__init__.py,sha256=f4IXc_-d8JZC77kAdIOBUuAwMrimTRDMC3akfwlzZ2M,96361
-aiohomematic/central/decorators.py,sha256=vrujdw2QMXva-7DGXMQyittujx0q7cPuGD-SCeQlD30,6886
+aiohomematic/central/__init__.py,sha256=UmPIumAjMLCfkbaMic_jvdH2V1feP0uqcsdS9ji14jo,96600
+aiohomematic/central/decorators.py,sha256=ja0d5MujL-Kfv399XIPRgiUxeyf67HwNWAuD7nmFJzg,6902
 aiohomematic/central/rpc_server.py,sha256=EhvBy8oMjBTR8MvH5QXo3lvlsCNJrvu6B85_CAg6sG8,10742
-aiohomematic/client/__init__.py,sha256=dMCDQIDyPc01Z4BvPsWIe688Bqtq81l51YRis22iKok,74131
+aiohomematic/client/__init__.py,sha256=TYeVOGNVsGSCoaL1v9z1F8Sfx-Aq7zzz-yComAnnh8E,74365
 aiohomematic/client/_rpc_errors.py,sha256=IaYjX60mpBJ43gDCJjuUSVraamy5jXHTRjOnutK4azs,2962
-aiohomematic/client/json_rpc.py,sha256=DtK4xdnZPVw-drWZ4HW-t0zp8Q0p3oYSn6RNfd01YYU,51331
-aiohomematic/client/rpc_proxy.py,sha256=T6tmfBAJJSFxzBLrhKJc6_KiHyTs5EVnStQsVJA5YkY,11604
+aiohomematic/client/json_rpc.py,sha256=82uVldmvNEB_F9BA_2oA55UmThRJRW2wRTPbcJiBvQg,51580
+aiohomematic/client/rpc_proxy.py,sha256=Am-MTLCVtQDPm2AOjVy1Bb4uulwdV2J6172SQRjdbso,11844
 aiohomematic/model/__init__.py,sha256=gUYa8ROWSbXjZTWUTmINZ1bbYAxGkVpA-onxaJN2Iso,5436
-aiohomematic/model/data_point.py,sha256=VdwzjRrBDaYhWyIQL4JVC9wYTFMSwvwymYSEAPxjms8,41573
-aiohomematic/model/device.py,sha256=K_xIRA5Jc2xC8iQcmdKUkR8O4BCoxK7MOfy1s4YQY8Q,52896
-aiohomematic/model/event.py,sha256=uO6Z2pCZEU_8MR8uRIIZjX8IL0rFh7sNhhTNT8yFoVU,6852
+aiohomematic/model/data_point.py,sha256=PqxMmKDqpUpkPO48WxNC5xeC9dPso5u8lQcKxwjusnw,41578
+aiohomematic/model/device.py,sha256=gK-4truXJMNJcU6vCIW7xV2rYHsrRCLtyM89xS2-g5I,52884
+aiohomematic/model/event.py,sha256=iyRW5569nttjGUa9iBeLHACviwVims2HiXrQFEz259M,6849
 aiohomematic/model/support.py,sha256=MQJVuE1C043VRs7t7Ld7kZ1quMmIDNXjzwNKW1LQtEs,19622
 aiohomematic/model/update.py,sha256=R3uUA61m-UQNNGkRod3vES66AgkPKay_CPyyrd-nqVI,5140
 aiohomematic/model/calculated/__init__.py,sha256=JNtxK4-XZeyR6MxfKVPdcF6ezQliQYTWEDoeOChumaE,2966
 aiohomematic/model/calculated/climate.py,sha256=rm9b4rCrmsZAA5_dzP6YRtahdveI97581_EnC4utqpg,10499
-aiohomematic/model/calculated/data_point.py,sha256=ESUqwolPViXPuH9hvL0q5FMvsGXjcqxeyySpNTUAMU8,11587
+aiohomematic/model/calculated/data_point.py,sha256=1LluGPB4YHfyC7gAXEBYi2Hqg9SP8Z_WCz3HLGJxNe0,11506
 aiohomematic/model/calculated/operating_voltage_level.py,sha256=99A8HvahVS4IxpgK1dsgQXHfeubU7JI2c0ObagbnSNQ,13505
 aiohomematic/model/calculated/support.py,sha256=GBD35_OR3TEAWo5ADeH_gk2Ebw9pHOtOnOS7umCkXB0,7989
 aiohomematic/model/custom/__init__.py,sha256=JxJXyr2CgKlj-jc1xQ14lbMT76vvswfLUecwj8RJCXA,6073
 aiohomematic/model/custom/climate.py,sha256=OnkZKxJKInrP52Tqu_hPcDDZbyL0wTMaIjWuBJ3th_k,57292
 aiohomematic/model/custom/const.py,sha256=s4iqhwvt8x41h4-CtMCyXwryGHuBNbhBrcJ5zGVRFJU,4939
 aiohomematic/model/custom/cover.py,sha256=KQzLEoPkKgZ2oi2oblUrGReQnT_0WAuseWAxu_xH5_Y,29035
-aiohomematic/model/custom/data_point.py,sha256=D36sRWsPdh6s-WSR1CxsnJCyp7PpROV2wVyExTXEAKA,14108
-aiohomematic/model/custom/definition.py,sha256=miZssuy1u5EcQ4opOWo9n0Eko-2aIK9f3MAKYiMmJb8,35640
-aiohomematic/model/custom/light.py,sha256=JC7GeU87gObBN0b1fCjm0VzgCtoytWsmq2Sd-fQqBGM,44426
+aiohomematic/model/custom/data_point.py,sha256=c0R7r6uAAZjxW01eUmmeHEe9doKtZYwZfUJbspMLjEM,14102
+aiohomematic/model/custom/definition.py,sha256=lZX7nSFxbXL0SHCZQFpLBSs6NbVx8fNdDV6tPCHsy00,35759
+aiohomematic/model/custom/light.py,sha256=_WDRxjEG8pjFKEjs_8pFiIyCykPRdSfi7SULk7srccA,44426
 aiohomematic/model/custom/lock.py,sha256=iJY8jiJA_HRynpbeACEQ_kzwiXOfAaT2IcF1FbXc0xY,11974
 aiohomematic/model/custom/siren.py,sha256=iaCJuRWiQH-r_ckhPZGRfmzxI8PddBBA5z_Jo78f1qI,9763
 aiohomematic/model/custom/support.py,sha256=FPhC3kp7blJu4jWHWAmXUXv4JWJu5nhQkrr8dyYxFas,1431
@@ -44,16 +44,16 @@ aiohomematic/model/generic/__init__.py,sha256=-4yben7G-QKBWMWpusrLkGo65a4IXIPYoi
 aiohomematic/model/generic/action.py,sha256=VDFCAkX0TkXV4xh3ya0AUIKnjOKF_rEobI6qdW5mAOQ,975
 aiohomematic/model/generic/binary_sensor.py,sha256=yABUafcBmPHLNAkdj_malYroBZc5UaunYLhmRtS2nGU,865
 aiohomematic/model/generic/button.py,sha256=3ahmj1BJZfdh6h6YV-urC8UwcKRp94QPOQtsF0fBI3Y,718
-aiohomematic/model/generic/data_point.py,sha256=P89BuRm8pWUBvCeR8XVHE2A1SqYb53REJCCOUnoKN34,6062
+aiohomematic/model/generic/data_point.py,sha256=eUOB8H-7PPKcjV8BKVPYlme519ppI1-odWslxQGcI-k,6062
 aiohomematic/model/generic/number.py,sha256=WNu4EB_npDZ8f7RrCrab1g9KzRtG8dziUvNQApEKXYk,2656
 aiohomematic/model/generic/select.py,sha256=-CXHdvzwWGp74t5UVdIWOFhlcW7bf0hcuGriBl7EWXk,1516
 aiohomematic/model/generic/sensor.py,sha256=ueqXw9bkFFJeD_mer6idpMTGFg6rweDEUNOgqsF22NA,2240
 aiohomematic/model/generic/switch.py,sha256=Y5Bml60QoHs14mfsMvhsk7S7I-2QSBoB7KWHMCJak3Q,1820
 aiohomematic/model/generic/text.py,sha256=AOMZCHgPO2v4lza-OI0J6WNsQcUOvab9HA5sRN8NQZQ,832
-aiohomematic/model/hub/__init__.py,sha256=qQkjMYd9-xE5iWvN-sMTcDvHIghz7g0z7u2ja73vaKQ,13503
+aiohomematic/model/hub/__init__.py,sha256=ml9uhexfzQ9LiQfob1yMf34mVbmi12-rMJweWYvWZlc,13503
 aiohomematic/model/hub/binary_sensor.py,sha256=yqBXEzVS7zMoY4N7agwQ70ypAgIRkfUeBNCInsQV_kA,730
 aiohomematic/model/hub/button.py,sha256=fEtBIxKF32kyacaCgsDLohw1exDpFtE7SCwEYgBAlOY,868
-aiohomematic/model/hub/data_point.py,sha256=7AKkZM4cpO3qhVF5rKPs25H2JKGjHQlHd-wJdf73Wcg,10631
+aiohomematic/model/hub/data_point.py,sha256=FQrBi9BdwIMJH7ul1bSaNEspsBkC5ZouSQLd3Y33ROs,10622
 aiohomematic/model/hub/number.py,sha256=zS5ft2wkUUJ0NkUlhkWvbXCeMcI9v-gH36NVCdrNtcU,1215
 aiohomematic/model/hub/select.py,sha256=ENF1TMk5jrNbk7lspNTfWIROMifjJMrllnu6htM1C2E,1652
 aiohomematic/model/hub/sensor.py,sha256=F--BHrgziizBOkXTupwV0ZZlzNnjsWrL9qnkHQv-lEE,1170
@@ -66,11 +66,12 @@ aiohomematic/rega_scripts/get_system_variable_descriptions.fn,sha256=UKXvC0_5lSA
 aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m04cHjVj4kIOnUUgpY,279
 aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
 aiohomematic/store/__init__.py,sha256=PHwF_tw_zL20ODwLywHgpOLWrghQo_BMZzeiQSXN1Fc,1081
-aiohomematic/store/dynamic.py,sha256=7grL-rpIh4CYWVNqL7WO66zRJuw7qfi34S2sxSbsOac,22049
+aiohomematic/store/dynamic.py,sha256=3i8oajVhfTeckAuOhwTyIxrd-eb1fl5VxEdK3NPfisw,22323
 aiohomematic/store/persistent.py,sha256=SBL8AhqUzpoPtJ50GkLYHwvRJS52fBWqNPjgvykxbY8,40233
-aiohomematic/store/visibility.py,sha256=VAoaHMsCnIwcaTQjx_RkpPb64o5xjVNRldCfB2MGc1M,31680
-aiohomematic-2025.10.22.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
-aiohomematic-2025.10.22.dist-info/METADATA,sha256=EG8oIYVQQVkO-mIfd5qUP8m1dxEULgWytT8DReLcBlo,7672
-aiohomematic-2025.10.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.22.dist-info/top_level.txt,sha256=iGUvt1N-E72vKRq7Anpp62HwkQngStrUK0JfL1zj1TE,13
-aiohomematic-2025.10.22.dist-info/RECORD,,
+aiohomematic/store/visibility.py,sha256=ZaqxN_FIsvpYZvCZWu0YSlWLtrFmAfUYILBYIXxPJZs,31622
+aiohomematic-2025.10.25.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic-2025.10.25.dist-info/METADATA,sha256=I3qrHxmZ2K1HTKCLARxj444R9y0PrOuhhmJ4UavC8vM,7950
+aiohomematic-2025.10.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.25.dist-info/entry_points.txt,sha256=tzk3wIE-hXNhLEiefCCDhIiRT7DYY9MePAwGw-kPmWI,57
+aiohomematic-2025.10.25.dist-info/top_level.txt,sha256=iGUvt1N-E72vKRq7Anpp62HwkQngStrUK0JfL1zj1TE,13
+aiohomematic-2025.10.25.dist-info/RECORD,,

aiohomematic-2025.10.25.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aiohomematic = aiohomematic.hmcli:main