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

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(
-                        _exec_backend_system_callback(*args, **kwargs),
+                        target=_exec_backend_system_callback(*args, **kwargs),
                         name="wrapper_backend_system_callback",
                     )
             except Exception as exc:
@@ -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(
-                    _async_wrap_sync(_exec_event_callback, *args, **kwargs),
+                    target=_async_wrap_sync(_exec_event_callback, *args, **kwargs),
                     name="wrapper_event_callback",
                 )
                 return

aiohomematic/central/xml_rpc_server.py

@@ -27,15 +27,18 @@ _LOGGER: Final = logging.getLogger(__name__)
 class RPCFunctions:
     """The XML-RPC functions the backend will expect."""
 
-    def __init__(self, xml_rpc_server: XmlRpcServer) -> None:
+    # Disable kw-only linter for this class since XML-RPC signatures are positional by protocol
+    __kwonly_check__ = False
+
+    def __init__(self, *, xml_rpc_server: XmlRpcServer) -> None:
         """Init RPCFunctions."""
         self._xml_rpc_server: Final = xml_rpc_server
 
-    def event(self, interface_id: str, channel_address: str, parameter: str, value: Any) -> None:
+    def event(self, interface_id: str, channel_address: str, parameter: str, value: Any, /) -> None:
         """If a device emits some sort event, we will handle it here."""
-        if central := self.get_central(interface_id):
+        if central := self.get_central(interface_id=interface_id):
             central.looper.create_task(
-                central.data_point_event(
+                target=central.data_point_event(
                     interface_id=interface_id,
                     channel_address=channel_address,
                     parameter=parameter,
@@ -45,7 +48,7 @@ class RPCFunctions:
             )
 
     @callback_backend_system(system_event=BackendSystemEvent.ERROR)
-    def error(self, interface_id: str, error_code: str, msg: str) -> None:
+    def error(self, interface_id: str, error_code: str, msg: str, /) -> None:
         """When some error occurs the backend will send its error message here."""
         # Structured boundary log (warning level). XML-RPC server received error notification.
         try:
@@ -66,32 +69,34 @@ class RPCFunctions:
             str(msg),
         )
 
-    def listDevices(self, interface_id: str) -> list[dict[str, Any]]:
+    def listDevices(self, interface_id: str, /) -> list[dict[str, Any]]:
         """Return already existing devices to the backend."""
-        if central := self.get_central(interface_id):
+        if central := self.get_central(interface_id=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:
+    def newDevices(self, interface_id: str, device_descriptions: list[dict[str, Any]], /) -> None:
         """Add new devices send from the backend."""
         central: hmcu.CentralUnit | None
-        if central := self.get_central(interface_id):
+        if central := self.get_central(interface_id=interface_id):
             central.looper.create_task(
-                central.add_new_devices(interface_id=interface_id, device_descriptions=tuple(device_descriptions)),
+                target=central.add_new_devices(
+                    interface_id=interface_id, device_descriptions=tuple(device_descriptions)
+                ),
                 name=f"newDevices-{interface_id}",
             )
 
-    def deleteDevices(self, interface_id: str, addresses: list[str]) -> None:
+    def deleteDevices(self, interface_id: str, addresses: list[str], /) -> None:
         """Delete devices send from the backend."""
         central: hmcu.CentralUnit | None
-        if central := self.get_central(interface_id):
+        if central := self.get_central(interface_id=interface_id):
             central.looper.create_task(
-                central.delete_devices(interface_id=interface_id, addresses=tuple(addresses)),
+                target=central.delete_devices(interface_id=interface_id, addresses=tuple(addresses)),
                 name=f"deleteDevices-{interface_id}",
             )
 
     @callback_backend_system(system_event=BackendSystemEvent.UPDATE_DEVICE)
-    def updateDevice(self, interface_id: str, address: str, hint: int) -> None:
+    def updateDevice(self, interface_id: str, address: str, hint: int, /) -> None:
         """
         Update a device.
 
@@ -106,7 +111,7 @@ class RPCFunctions:
         )
 
     @callback_backend_system(system_event=BackendSystemEvent.REPLACE_DEVICE)
-    def replaceDevice(self, interface_id: str, old_device_address: str, new_device_address: str) -> None:
+    def replaceDevice(self, interface_id: str, old_device_address: str, new_device_address: str, /) -> None:
         """Replace a device. Probably irrelevant for us."""
         _LOGGER.debug(
             "REPLACEDEVICE: interface_id = %s, oldDeviceAddress = %s, newDeviceAddress = %s",
@@ -116,7 +121,7 @@ class RPCFunctions:
         )
 
     @callback_backend_system(system_event=BackendSystemEvent.RE_ADDED_DEVICE)
-    def readdedDevice(self, interface_id: str, addresses: list[str]) -> None:
+    def readdedDevice(self, interface_id: str, addresses: list[str], /) -> None:
         """
         Re-Add device from the backend.
 
@@ -130,9 +135,9 @@ class RPCFunctions:
             str(addresses),
         )
 
-    def get_central(self, interface_id: str) -> hmcu.CentralUnit | None:
+    def get_central(self, *, interface_id: str) -> hmcu.CentralUnit | None:
         """Return the central by interface_id."""
-        return self._xml_rpc_server.get_central(interface_id)
+        return self._xml_rpc_server.get_central(interface_id=interface_id)
 
 
 # Restrict to specific paths.
@@ -159,7 +164,9 @@ class AioHomematicXMLRPCServer(SimpleXMLRPCServer):
     system_listMethods(self, interface_id: str.
     """
 
-    def system_listMethods(self, interface_id: str | None = None) -> list[str]:
+    __kwonly_check__ = False
+
+    def system_listMethods(self, interface_id: str | None = None, /) -> list[str]:
         """Return a list of the methods supported by the server."""
         return SimpleXMLRPCServer.system_listMethods(self)
 
@@ -172,6 +179,7 @@ class XmlRpcServer(threading.Thread):
 
     def __init__(
         self,
+        *,
         ip_addr: str,
         port: int,
     ) -> None:
@@ -192,10 +200,10 @@ class XmlRpcServer(threading.Thread):
         )
         self._simple_xml_rpc_server.register_introspection_functions()
         self._simple_xml_rpc_server.register_multicall_functions()
-        self._simple_xml_rpc_server.register_instance(RPCFunctions(self), allow_dotted_names=True)
+        self._simple_xml_rpc_server.register_instance(RPCFunctions(xml_rpc_server=self), allow_dotted_names=True)
         self._centrals: Final[dict[str, hmcu.CentralUnit]] = {}
 
-    def __new__(cls, ip_addr: str, port: int) -> XmlRpcServer:  # noqa: PYI034
+    def __new__(cls, ip_addr: str, port: int) -> XmlRpcServer:  # noqa: PYI034  # kwonly: disable
         """Create new XmlRPC server."""
         if (xml_rpc := cls._instances.get((ip_addr, port))) is None:
             _LOGGER.debug("Creating XmlRpc server")
@@ -240,17 +248,17 @@ class XmlRpcServer(threading.Thread):
         """Return if thread is active."""
         return self._started.is_set() is True  # type: ignore[attr-defined]
 
-    def add_central(self, central: hmcu.CentralUnit) -> None:
+    def add_central(self, *, central: hmcu.CentralUnit) -> None:
         """Register a central in the XmlRPC-Server."""
         if not self._centrals.get(central.name):
             self._centrals[central.name] = central
 
-    def remove_central(self, central: hmcu.CentralUnit) -> None:
+    def remove_central(self, *, central: hmcu.CentralUnit) -> None:
         """Unregister a central from XmlRPC-Server."""
         if self._centrals.get(central.name):
             del self._centrals[central.name]
 
-    def get_central(self, interface_id: str) -> hmcu.CentralUnit | None:
+    def get_central(self, *, interface_id: str) -> hmcu.CentralUnit | None:
         """Return a central by interface_id."""
         for central in self._centrals.values():
             if central.has_client(interface_id=interface_id):
@@ -263,7 +271,7 @@ class XmlRpcServer(threading.Thread):
         return len(self._centrals) == 0
 
 
-def create_xml_rpc_server(ip_addr: str = IP_ANY_V4, port: int = PORT_ANY) -> XmlRpcServer:
+def create_xml_rpc_server(*, ip_addr: str = IP_ANY_V4, port: int = PORT_ANY) -> XmlRpcServer:
     """Register the xml rpc server."""
     xml_rpc = XmlRpcServer(ip_addr=ip_addr, port=port)
     if not xml_rpc.started: