aiohomematic 2025.10.21__py3-none-any.whl → 2025.10.24__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},
@@ -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.21"
+VERSION: Final = "2025.10.24"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -303,7 +303,7 @@ class EventKey(StrEnum):
     INTERFACE_ID = "interface_id"
     MODEL = "model"
     PARAMETER = "parameter"
-    PONG_MISMATCH_ALLOWED = "pong_mismatch_allowed"
+    PONG_MISMATCH_ACCEPTABLE = "pong_mismatch_allowed"
     PONG_MISMATCH_COUNT = "pong_mismatch_count"
     SECONDS_SINCE_LAST_EVENT = "seconds_since_last_event"
     TYPE = "type"

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",
     )