aiohomematic 2025.9.3__py3-none-any.whl → 2025.9.5__py3-none-any.whl

aiohomematic/caches/dynamic.py

@@ -170,7 +170,7 @@ class DeviceDetailsCache:
         self._refreshed_at = INIT_DATETIME
 
     async def load(self, direct_call: bool = False) -> None:
-        """Fetch names from backend."""
+        """Fetch names from the backend."""
         if direct_call is False and changed_within_seconds(
             last_change=self._refreshed_at, max_age=int(MAX_CACHE_AGE / 3)
         ):
@@ -286,7 +286,7 @@ class CentralDataCache:
         self._refreshed_at: Final[dict[Interface, datetime]] = {}
 
     async def load(self, direct_call: bool = False, interface: Interface | None = None) -> None:
-        """Fetch data from backend."""
+        """Fetch data from the backend."""
         _LOGGER.debug("load: Loading device data for %s", self._central.name)
         for client in self._central.clients:
             if interface and interface != client.interface:

aiohomematic/central/__init__.py

@@ -11,7 +11,7 @@ interfaces, devices, channels, data points, events, and background jobs.
 
 The central unit ties together the various submodules: caches, client adapters
 (JSON-RPC/XML-RPC), device and data point models, and visibility/description caches.
-It exposes high-level APIs to query and manipulate the CCU state while
+It exposes high-level APIs to query and manipulate the backend state while
 encapsulating transport and scheduling details.
 
 Public API (selected)
@@ -191,7 +191,7 @@ INTERFACE_EVENT_SCHEMA = vol.Schema(
 
 
 class CentralUnit(LogContextMixin, PayloadMixin):
-    """Central unit that collects everything to handle communication from/to CCU/Homegear."""
+    """Central unit that collects everything to handle communication from/to the backend."""
 
     def __init__(self, central_config: CentralConfig) -> None:
         """Init the central unit."""
@@ -208,7 +208,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         self._xml_rpc_server: xmlrpc.XmlRpcServer | None = None
         self._json_rpc_client: JsonRpcAioHttpClient | None = None
 
-        # Caches for CCU data
+        # Caches for the backend data
         self._data_cache: Final = CentralDataCache(central=self)
         self._device_details: Final = DeviceDetailsCache(central=self)
         self._device_descriptions: Final = DeviceDescriptionCache(central=self)
@@ -233,7 +233,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 CCU for parameter updates
+        # Re-Fired events from the backend for parameter updates
         self._backend_parameter_callbacks: Final[set[Callable]] = set()
         # Signature: (event_type, event_data)
         # Events like INTERFACE, KEYPRESS, ...
@@ -665,7 +665,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                     and interface_config.interface not in self.primary_client.system_information.available_interfaces
                 ):
                     _LOGGER.warning(
-                        "CREATE_CLIENTS failed: Interface: %s is not available for backend %s",
+                        "CREATE_CLIENTS failed: Interface: %s is not available for the backend %s",
                         interface_config.interface,
                         self.name,
                     )
@@ -721,7 +721,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         for client in self._clients.copy().values():
             if client.interface not in self.system_information.available_interfaces:
                 _LOGGER.debug(
-                    "INIT_CLIENTS failed: Interface: %s is not available for backend %s",
+                    "INIT_CLIENTS failed: Interface: %s is not available for the backend %s",
                     client.interface,
                     self.name,
                 )
@@ -1211,7 +1211,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
 
     @callback_backend_system(system_event=BackendSystemEvent.LIST_DEVICES)
     def list_devices(self, interface_id: str) -> list[DeviceDescription]:
-        """Return already existing devices to CCU / Homegear."""
+        """Return already existing devices to the backend."""
         result = self._device_descriptions.get_raw_device_descriptions(interface_id=interface_id)
         _LOGGER.debug("LIST_DEVICES: interface_id = %s, channel_count = %i", interface_id, len(result))
         return result
@@ -1274,13 +1274,13 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         self._last_event_seen_for_interface[interface_id] = datetime.now()
 
     async def execute_program(self, pid: str) -> bool:
-        """Execute a program on CCU / Homegear."""
+        """Execute a program on the backend."""
         if client := self.primary_client:
             return await client.execute_program(pid=pid)
         return False
 
     async def set_program_state(self, pid: str, state: bool) -> bool:
-        """Execute a program on CCU / Homegear."""
+        """Execute a program on the backend."""
         if client := self.primary_client:
             return await client.set_program_state(pid=pid, state=state)
         return False
@@ -1310,13 +1310,13 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         )
 
     async def get_system_variable(self, legacy_name: str) -> Any | None:
-        """Get system variable from CCU / Homegear."""
+        """Get system variable from the backend."""
         if client := self.primary_client:
             return await client.get_system_variable(legacy_name)
         return None
 
     async def set_system_variable(self, legacy_name: str, value: Any) -> None:
-        """Set variable value on CCU/Homegear."""
+        """Set variable value on the backend."""
         if dp := self.get_sysvar_data_point(legacy_name=legacy_name):
             await dp.send_variable(value=value)
         else:
@@ -1552,7 +1552,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         """
         Fire backend_parameter callback in central.
 
-        Re-Fired events from CCU for parameter updates.
+        Re-Fired events from the backend for parameter updates.
         """
         for callback_handler in self._backend_parameter_callbacks:
             try:
@@ -1597,7 +1597,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
 
 
 class _Scheduler(threading.Thread):
-    """Periodically check connection to CCU / Homegear, and load data when required."""
+    """Periodically check connection to the backend, and load data when required."""
 
     def __init__(self, central: CentralUnit) -> None:
         """Init the connection checker."""

aiohomematic/central/xml_rpc_server.py

@@ -4,7 +4,7 @@
 XML-RPC server module.
 
 Provides the XML-RPC server which handles communication
-with the CCU or Homegear.
+with the backend.
 """
 
 from __future__ import annotations
@@ -25,7 +25,7 @@ _LOGGER: Final = logging.getLogger(__name__)
 
 # pylint: disable=invalid-name
 class RPCFunctions:
-    """The XML-RPC functions the CCU or Homegear will expect."""
+    """The XML-RPC functions the backend will expect."""
 
     def __init__(self, xml_rpc_server: XmlRpcServer) -> None:
         """Init RPCFunctions."""
@@ -46,7 +46,7 @@ class RPCFunctions:
 
     @callback_backend_system(system_event=BackendSystemEvent.ERROR)
     def error(self, interface_id: str, error_code: str, msg: str) -> None:
-        """When some error occurs the CCU / Homegear will send its error message here."""
+        """When some error occurs the backend will send its error message here."""
         # Structured boundary log (warning level). XML-RPC server received error notification.
         try:
             raise RuntimeError(str(msg))
@@ -67,13 +67,13 @@ class RPCFunctions:
         )
 
     def listDevices(self, interface_id: str) -> list[dict[str, Any]]:
-        """Return already existing devices to CCU / Homegear."""
+        """Return already existing devices to the backend."""
         if central := self.get_central(interface_id):
             return [dict(device_description) for device_description in central.list_devices(interface_id=interface_id)]
         return []
 
     def newDevices(self, interface_id: str, device_descriptions: list[dict[str, Any]]) -> None:
-        """Add new devices send from backend."""
+        """Add new devices send from the backend."""
         central: hmcu.CentralUnit | None
         if central := self.get_central(interface_id):
             central.looper.create_task(
@@ -82,7 +82,7 @@ class RPCFunctions:
             )
 
     def deleteDevices(self, interface_id: str, addresses: list[str]) -> None:
-        """Delete devices send from backend."""
+        """Delete devices send from the backend."""
         central: hmcu.CentralUnit | None
         if central := self.get_central(interface_id):
             central.looper.create_task(
@@ -118,7 +118,7 @@ class RPCFunctions:
     @callback_backend_system(system_event=BackendSystemEvent.RE_ADDED_DEVICE)
     def readdedDevice(self, interface_id: str, addresses: list[str]) -> None:
         """
-        Re-Add device from backend.
+        Re-Add device from the backend.
 
         Probably irrelevant for us.
         Gets called when a known devices is put into learn-mode
@@ -160,17 +160,12 @@ class AioHomematicXMLRPCServer(SimpleXMLRPCServer):
     """
 
     def system_listMethods(self, interface_id: str | None = None) -> list[str]:
-        """
-        Return a list of the methods supported by the server.
-
-        system.listMethods() => ['add', 'subtract', 'multiple']
-        Required for HomeMatic CCU usage.
-        """
+        """Return a list of the methods supported by the server."""
         return SimpleXMLRPCServer.system_listMethods(self)
 
 
 class XmlRpcServer(threading.Thread):
-    """XML-RPC server thread to handle messages from CCU / Homegear."""
+    """XML-RPC server thread to handle messages from the backend."""
 
     _initialized: bool = False
     _instances: Final[dict[tuple[str, int], XmlRpcServer]] = {}

aiohomematic/client/__init__.py

@@ -248,7 +248,7 @@ class Client(ABC, LogContextMixin):
         return self.interface in INTERFACES_SUPPORTING_FIRMWARE_UPDATES
 
     async def initialize_proxy(self) -> ProxyInitState:
-        """Init the proxy has to tell the CCU / Homegear where to send the events."""
+        """Init the proxy has to tell the backend where to send the events."""
 
         if not self.supports_xml_rpc:
             if device_descriptions := await self.list_devices():
@@ -277,7 +277,7 @@ class Client(ABC, LogContextMixin):
         return ProxyInitState.INIT_SUCCESS
 
     async def deinitialize_proxy(self) -> ProxyInitState:
-        """De-init to stop CCU from sending events for this remote."""
+        """De-init to stop the backend from sending events for this remote."""
         if not self.supports_xml_rpc:
             return ProxyInitState.DE_INIT_SUCCESS
 
@@ -356,12 +356,12 @@ class Client(ABC, LogContextMixin):
     @abstractmethod
     @inspector(re_raise=False, measure_performance=True)
     async def fetch_all_device_data(self) -> None:
-        """Fetch all device data from CCU."""
+        """Fetch all device data from the backend."""
 
     @abstractmethod
     @inspector(re_raise=False, measure_performance=True)
     async def fetch_device_details(self) -> None:
-        """Fetch names from backend."""
+        """Fetch names from the backend."""
 
     @inspector(re_raise=False, no_raise_return=False)
     async def is_connected(self) -> bool:
@@ -420,39 +420,39 @@ class Client(ABC, LogContextMixin):
     @abstractmethod
     @inspector(re_raise=False, no_raise_return=False)
     async def check_connection_availability(self, handle_ping_pong: bool) -> bool:
-        """Send ping to CCU to generate PONG event."""
+        """Send ping to the backend to generate PONG event."""
 
     @abstractmethod
     @inspector
     async def execute_program(self, pid: str) -> bool:
-        """Execute a program on CCU / Homegear."""
+        """Execute a program on the backend."""
 
     @abstractmethod
     @inspector
     async def set_program_state(self, pid: str, state: bool) -> bool:
-        """Set the program state on CCU / Homegear."""
+        """Set the program state on the backend."""
 
     @abstractmethod
     @inspector(measure_performance=True)
     async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
-        """Set a system variable on CCU / Homegear."""
+        """Set a system variable on the backend."""
 
     @abstractmethod
     @inspector
     async def delete_system_variable(self, name: str) -> bool:
-        """Delete a system variable from CCU / Homegear."""
+        """Delete a system variable from the backend."""
 
     @abstractmethod
     @inspector
     async def get_system_variable(self, name: str) -> Any:
-        """Get single system variable from CCU / Homegear."""
+        """Get single system variable from the backend."""
 
     @abstractmethod
     @inspector(re_raise=False)
     async def get_all_system_variables(
         self, markers: tuple[DescriptionMarker | str, ...]
     ) -> tuple[SystemVariableData, ...] | None:
-        """Get all system variables from CCU / Homegear."""
+        """Get all system variables from the backend."""
 
     @abstractmethod
     @inspector(re_raise=False)
@@ -483,7 +483,7 @@ class Client(ABC, LogContextMixin):
 
     @inspector(re_raise=False)
     async def get_device_description(self, device_address: str) -> DeviceDescription | None:
-        """Get device descriptions from CCU / Homegear."""
+        """Get device descriptions from the backend."""
         try:
             if device_description := cast(
                 DeviceDescription | None,
@@ -560,7 +560,7 @@ class Client(ABC, LogContextMixin):
         parameter: str,
         call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
     ) -> Any:
-        """Return a value from CCU."""
+        """Return a value from the backend."""
         try:
             _LOGGER.debug(
                 "GET_VALUE: channel_address %s, parameter %s, paramset_key, %s, source:%s",
@@ -707,7 +707,7 @@ class Client(ABC, LogContextMixin):
         call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
     ) -> dict[str, Any]:
         """
-        Return a paramset from CCU.
+        Return a paramset from the backend.
 
         Address is usually the channel_address,
         but for bidcos devices there is a master paramset at the device.
@@ -835,7 +835,7 @@ class Client(ABC, LogContextMixin):
         values: dict[str, Any],
         rx_mode: CommandRxMode | None = None,
     ) -> None:
-        """Put paramset into CCU."""
+        """Put paramset into the backend."""
         if rx_mode:
             await self._proxy.putParamset(channel_address, paramset_key, values, rx_mode)
         else:
@@ -946,7 +946,7 @@ class Client(ABC, LogContextMixin):
     async def _get_paramset_description(
         self, address: str, paramset_key: ParamsetKey
     ) -> dict[str, ParameterData] | None:
-        """Get paramset description from CCU."""
+        """Get paramset description from the backend."""
         try:
             return cast(
                 dict[str, ParameterData],
@@ -979,7 +979,7 @@ class Client(ABC, LogContextMixin):
 
     @inspector(re_raise=False, measure_performance=True)
     async def list_devices(self) -> tuple[DeviceDescription, ...] | None:
-        """List devices of homematic backend."""
+        """List devices of the backend."""
         try:
             return tuple(await self._proxy_read.listDevices())
         except BaseHomematicException as bhexc:
@@ -1089,7 +1089,7 @@ class ClientCCU(Client):
 
     @inspector(re_raise=False, measure_performance=True)
     async def fetch_all_device_data(self) -> None:
-        """Fetch all device data from CCU."""
+        """Fetch all device data from the backend."""
         try:
             if all_device_data := await self._json_rpc_client.get_all_device_data(interface=self.interface):
                 _LOGGER.debug(
@@ -1140,12 +1140,12 @@ class ClientCCU(Client):
 
     @inspector
     async def execute_program(self, pid: str) -> bool:
-        """Execute a program on CCU."""
+        """Execute a program on the backend."""
         return await self._json_rpc_client.execute_program(pid=pid)
 
     @inspector
     async def set_program_state(self, pid: str, state: bool) -> bool:
-        """Set the program state on CCU."""
+        """Set the program state on the backend."""
         return await self._json_rpc_client.set_program_state(pid=pid, state=state)
 
     @inspector
@@ -1165,24 +1165,24 @@ class ClientCCU(Client):
 
     @inspector(measure_performance=True)
     async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
-        """Set a system variable on CCU / Homegear."""
+        """Set a system variable on the backend."""
         return await self._json_rpc_client.set_system_variable(legacy_name=legacy_name, value=value)
 
     @inspector
     async def delete_system_variable(self, name: str) -> bool:
-        """Delete a system variable from CCU / Homegear."""
+        """Delete a system variable from the backend."""
         return await self._json_rpc_client.delete_system_variable(name=name)
 
     @inspector
     async def get_system_variable(self, name: str) -> Any:
-        """Get single system variable from CCU / Homegear."""
+        """Get single system variable from the backend."""
         return await self._json_rpc_client.get_system_variable(name=name)
 
     @inspector(re_raise=False)
     async def get_all_system_variables(
         self, markers: tuple[DescriptionMarker | str, ...]
     ) -> tuple[SystemVariableData, ...] | None:
-        """Get all system variables from CCU."""
+        """Get all system variables from the backend."""
         return await self._json_rpc_client.get_all_system_variables(markers=markers)
 
     @inspector(re_raise=False)
@@ -1192,7 +1192,7 @@ class ClientCCU(Client):
 
     @inspector(re_raise=False, no_raise_return={})
     async def get_all_rooms(self) -> dict[str, set[str]]:
-        """Get all rooms from CCU."""
+        """Get all rooms from the backend."""
         rooms: dict[str, set[str]] = {}
         channel_ids_room = await self._json_rpc_client.get_all_channel_ids_room()
         for address, channel_id in self.central.device_details.device_channel_ids.items():
@@ -1204,7 +1204,7 @@ class ClientCCU(Client):
 
     @inspector(re_raise=False, no_raise_return={})
     async def get_all_functions(self) -> dict[str, set[str]]:
-        """Get all functions from CCU."""
+        """Get all functions from the backend."""
         functions: dict[str, set[str]] = {}
         channel_ids_function = await self._json_rpc_client.get_all_channel_ids_function()
         for address, channel_id in self.central.device_details.device_channel_ids.items():
@@ -1220,7 +1220,7 @@ class ClientCCU(Client):
 
 
 class ClientJsonCCU(ClientCCU):
-    """Client implementation for CCU backend."""
+    """Client implementation for CCU-like backend (CCU-Jack, CuXD)."""
 
     @inspector
     async def init_client(self) -> None:
@@ -1239,7 +1239,7 @@ class ClientJsonCCU(ClientCCU):
 
     @inspector(re_raise=False)
     async def get_device_description(self, device_address: str) -> DeviceDescription | None:
-        """Get device descriptions from CCU / Homegear."""
+        """Get device descriptions from the backend."""
         try:
             if device_description := await self._json_rpc_client.get_device_description(
                 interface=self.interface, address=device_address
@@ -1257,7 +1257,7 @@ class ClientJsonCCU(ClientCCU):
         call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
     ) -> dict[str, Any]:
         """
-        Return a paramset from CCU.
+        Return a paramset from the backend.
 
         Address is usually the channel_address,
         but for bidcos devices there is a master paramset at the device.
@@ -1288,7 +1288,7 @@ class ClientJsonCCU(ClientCCU):
         parameter: str,
         call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
     ) -> Any:
-        """Return a value from CCU."""
+        """Return a value from the backend."""
         try:
             _LOGGER.debug(
                 "GET_VALUE: channel_address %s, parameter %s, paramset_key, %s, source:%s",
@@ -1334,7 +1334,7 @@ class ClientJsonCCU(ClientCCU):
     async def _get_paramset_description(
         self, address: str, paramset_key: ParamsetKey
     ) -> dict[str, ParameterData] | None:
-        """Get paramset description from CCU."""
+        """Get paramset description from the backend."""
         try:
             return cast(
                 dict[str, ParameterData],
@@ -1359,7 +1359,7 @@ class ClientJsonCCU(ClientCCU):
         values: dict[str, Any],
         rx_mode: CommandRxMode | None = None,
     ) -> None:
-        """Put paramset into CCU."""
+        """Put paramset into the backend."""
         # _values: list[dict[str, Any]] = []
         for parameter, value in values.items():
             await self._exec_set_value(
@@ -1441,7 +1441,7 @@ class ClientHomegear(Client):
 
     @inspector(re_raise=False)
     async def fetch_all_device_data(self) -> None:
-        """Fetch all device data from CCU."""
+        """Fetch all device data from the backend."""
         return
 
     @inspector(re_raise=False, measure_performance=True)
@@ -1481,36 +1481,36 @@ class ClientHomegear(Client):
 
     @inspector
     async def execute_program(self, pid: str) -> bool:
-        """Execute a program on Homegear."""
+        """Execute a program on the backend."""
         return True
 
     @inspector
     async def set_program_state(self, pid: str, state: bool) -> bool:
-        """Set the program state on Homegear."""
+        """Set the program state on the backend."""
         return True
 
     @inspector(measure_performance=True)
     async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
-        """Set a system variable on CCU / Homegear."""
+        """Set a system variable on the backend."""
         await self._proxy.setSystemVariable(legacy_name, value)
         return True
 
     @inspector
     async def delete_system_variable(self, name: str) -> bool:
-        """Delete a system variable from CCU / Homegear."""
+        """Delete a system variable from the backend."""
         await self._proxy.deleteSystemVariable(name)
         return True
 
     @inspector
     async def get_system_variable(self, name: str) -> Any:
-        """Get single system variable from CCU / Homegear."""
+        """Get single system variable from the backend."""
         return await self._proxy.getSystemVariable(name)
 
     @inspector(re_raise=False)
     async def get_all_system_variables(
         self, markers: tuple[DescriptionMarker | str, ...]
     ) -> tuple[SystemVariableData, ...] | None:
-        """Get all system variables from Homegear."""
+        """Get all system variables from the backend."""
         variables: list[SystemVariableData] = []
         if hg_variables := await self._proxy.getAllSystemVariables():
             for name, value in hg_variables.items():
@@ -1524,12 +1524,12 @@ class ClientHomegear(Client):
 
     @inspector(re_raise=False, no_raise_return={})
     async def get_all_rooms(self) -> dict[str, set[str]]:
-        """Get all rooms from Homegear."""
+        """Get all rooms from the backend."""
         return {}
 
     @inspector(re_raise=False, no_raise_return={})
     async def get_all_functions(self) -> dict[str, set[str]]:
-        """Get all functions from Homegear."""
+        """Get all functions from the backend."""
         return {}
 
     async def _get_system_information(self) -> SystemInformation:
@@ -1586,7 +1586,7 @@ class _ClientConfig:
             raise NoConnectionException(f"Unable to connect {extract_exc_args(exc=exc)}.") from exc
 
     async def _get_version(self) -> str:
-        """Return the version of the backend."""
+        """Return the version of the the backend."""
         if self.interface in (Interface.CCU_JACK, Interface.CUXD):
             return "0"
         check_proxy = await self._create_simple_xml_rpc_proxy()
@@ -1601,7 +1601,7 @@ class _ClientConfig:
     async def create_xml_rpc_proxy(
         self, auth_enabled: bool | None = None, max_workers: int = DEFAULT_MAX_WORKERS
     ) -> XmlRpcProxy:
-        """Return a XmlRPC proxy for backend communication."""
+        """Return a XmlRPC proxy for the backend communication."""
         config = self.central.config
         xml_rpc_headers = (
             build_xml_rpc_headers(
@@ -1624,7 +1624,7 @@ class _ClientConfig:
         return xml_proxy
 
     async def _create_simple_xml_rpc_proxy(self) -> XmlRpcProxy:
-        """Return a XmlRPC proxy for backend communication."""
+        """Return a XmlRPC proxy for the backend communication."""
         return await self.create_xml_rpc_proxy(auth_enabled=True, max_workers=0)
 
 

aiohomematic/client/_rpc_errors.py

@@ -3,7 +3,7 @@
 """
 Error mapping helpers for RPC transports.
 
-This module centralizes small, transport-agnostic utilities to turn backend
+This module centralizes small, transport-agnostic utilities to turn the backend
 errors into domain-specific exceptions with useful context. It is used by both
 JSON-RPC and XML-RPC clients.