aiohomematic 2025.10.4__py3-none-any.whl → 2025.10.6__py3-none-any.whl

aiohomematic/caches/visibility.py

@@ -171,8 +171,8 @@ _IGNORED_PARAMETERS: Final[frozenset[TParameterName]] = frozenset(
         "CLEAR_ERROR",
         "CLEAR_WINDOW_OPEN_SYMBOL",
         "CLOCK",
-        "CMD_RETL",  # CuXD
-        "CMD_RETS",  # CuXD
+        "CMD_RETL",  # CUxD
+        "CMD_RETS",  # CUxD
         "CONTROL_DIFFERENTIAL_TEMPERATURE",
         "DATE_TIME_UNKNOWN",
         "DECISION_VALUE",

aiohomematic/central/__init__.py

@@ -82,10 +82,10 @@ from aiohomematic.async_support import Looper, loop_check
 from aiohomematic.caches.dynamic import CentralDataCache, DeviceDetailsCache
 from aiohomematic.caches.persistent import DeviceDescriptionCache, ParamsetDescriptionCache
 from aiohomematic.caches.visibility import ParameterVisibilityCache
-from aiohomematic.central import xml_rpc_server as xmlrpc
+from aiohomematic.central import rpc_server as rpc
 from aiohomematic.central.decorators import callback_backend_system, callback_event
-from aiohomematic.client.json_rpc import JsonRpcAioHttpClient
-from aiohomematic.client.xml_rpc import XmlRpcProxy
+from aiohomematic.client.json_rpc import AioJsonRpcAioHttpClient
+from aiohomematic.client.rpc_proxy import AioXmlRpcProxy
 from aiohomematic.const import (
     CALLBACK_TYPE,
     CATEGORIES,
@@ -98,6 +98,7 @@ from aiohomematic.const import (
     DEFAULT_ENABLE_SYSVAR_SCAN,
     DEFAULT_HM_MASTER_POLL_AFTER_SEND_INTERVALS,
     DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
+    DEFAULT_INTERFACES_REQUIRING_PERIODIC_REFRESH,
     DEFAULT_MAX_READ_WORKERS,
     DEFAULT_PERIODIC_REFRESH_INTERVAL,
     DEFAULT_PROGRAM_MARKERS,
@@ -112,7 +113,6 @@ from aiohomematic.const import (
     DEVICE_FIRMWARE_DELIVERING_CHECK_INTERVAL,
     DEVICE_FIRMWARE_UPDATING_CHECK_INTERVAL,
     IGNORE_FOR_UN_IGNORE_PARAMETERS,
-    INTERFACES_REQUIRING_PERIODIC_REFRESH,
     IP_ANY_V4,
     LOCAL_HOST,
     PORT_ANY,
@@ -137,6 +137,7 @@ from aiohomematic.const import (
     Parameter,
     ParamsetKey,
     ProxyInitState,
+    RpcServerType,
     SourceOfDeviceCreation,
     SystemInformation,
 )
@@ -180,7 +181,7 @@ _LOGGER_EVENT: Final = logging.getLogger(f"{__package__}.event")
 
 # {central_name, central}
 CENTRAL_INSTANCES: Final[dict[str, CentralUnit]] = {}
-ConnectionProblemIssuer = JsonRpcAioHttpClient | XmlRpcProxy
+ConnectionProblemIssuer = AioJsonRpcAioHttpClient | AioXmlRpcProxy
 
 INTERFACE_EVENT_SCHEMA = vol.Schema(
     {
@@ -208,8 +209,8 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         self._url: Final = self._config.create_central_url()
         self._model: str | None = None
         self._looper = Looper()
-        self._xml_rpc_server: xmlrpc.XmlRpcServer | None = None
-        self._json_rpc_client: JsonRpcAioHttpClient | None = None
+        self._xml_rpc_server: rpc.XmlRpcServer | None = None
+        self._json_rpc_client: AioJsonRpcAioHttpClient | None = None
 
         # Caches for the backend data
         self._data_cache: Final = CentralDataCache(central=self)
@@ -248,9 +249,9 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         self._version: str | None = None
         # store last event received datetime by interface_id
         self._last_event_seen_for_interface: Final[dict[str, datetime]] = {}
-        self._xml_rpc_callback_ip: str = IP_ANY_V4
+        self._rpc_callback_ip: str = IP_ANY_V4
         self._listen_ip_addr: str = IP_ANY_V4
-        self._listen_port: int = PORT_ANY
+        self._listen_port_xml_rpc: int = PORT_ANY
 
     @property
     def available(self) -> bool:
@@ -260,7 +261,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
     @property
     def callback_ip_addr(self) -> str:
         """Return the xml rpc server callback ip address."""
-        return self._xml_rpc_callback_ip
+        return self._rpc_callback_ip
 
     @info_property(log_context=True)
     def url(self) -> str:
@@ -327,7 +328,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         return all(client.is_callback_alive() for client in self._clients.values())
 
     @property
-    def json_rpc_client(self) -> JsonRpcAioHttpClient:
+    def json_rpc_client(self) -> AioJsonRpcAioHttpClient:
         """Return the json rpc client."""
         if not self._json_rpc_client:
             self._json_rpc_client = self._config.create_json_rpc_client(central=self)
@@ -363,9 +364,9 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         return self._listen_ip_addr
 
     @property
-    def listen_port(self) -> int:
+    def listen_port_xml_rpc(self) -> int:
         """Return the xml rpc listening server port."""
-        return self._listen_port
+        return self._listen_port_xml_rpc
 
     @property
     def looper(self) -> Looper:
@@ -483,22 +484,22 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         if self._config.enabled_interface_configs and (
             ip_addr := await self._identify_ip_addr(port=self._config.connection_check_port)
         ):
-            self._xml_rpc_callback_ip = ip_addr
+            self._rpc_callback_ip = ip_addr
             self._listen_ip_addr = self._config.listen_ip_addr if self._config.listen_ip_addr else ip_addr
 
-        listen_port: int = (
-            self._config.listen_port
-            if self._config.listen_port
-            else self._config.callback_port or self._config.default_callback_port
+        port_xml_rpc: int = (
+            self._config.listen_port_xml_rpc
+            if self._config.listen_port_xml_rpc
+            else self._config.callback_port_xml_rpc or self._config.default_callback_port_xml_rpc
         )
         try:
             if (
-                xml_rpc_server := xmlrpc.create_xml_rpc_server(ip_addr=self._listen_ip_addr, port=listen_port)
-                if self._config.enable_server
+                xml_rpc_server := rpc.create_xml_rpc_server(ip_addr=self._listen_ip_addr, port=port_xml_rpc)
+                if self._config.enable_xml_rpc_server
                 else None
             ):
                 self._xml_rpc_server = xml_rpc_server
-                self._listen_port = xml_rpc_server.listen_port
+                self._listen_port_xml_rpc = xml_rpc_server.listen_port
                 self._xml_rpc_server.add_central(central=self)
         except OSError as oserr:
             self._state = CentralUnitState.STOPPED_BY_ERROR
@@ -514,7 +515,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                     )
         else:
             self._clients_started = await self._start_clients()
-            if self._config.enable_server:
+            if self._config.enable_xml_rpc_server:
                 self._start_scheduler()
 
         self._state = CentralUnitState.RUNNING
@@ -1166,7 +1167,8 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         return tuple(
             dev_desc
             for dev_desc in device_descriptions
-            if (dev_desc["ADDRESS"] if dev_desc["PARENT"] == "" else dev_desc["PARENT"]) not in known_addresses
+            if (dev_desc["ADDRESS"] if not (parent_address := dev_desc.get("PARENT")) else parent_address)
+            not in known_addresses
         )
 
     def _check_for_new_device_addresses(self, *, interface_id: str | None = None) -> Mapping[str, set[str]]:
@@ -1330,7 +1332,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 self._data_point_key_event_subscriptions[data_point.dpk] = []
             self._data_point_key_event_subscriptions[data_point.dpk].append(data_point.event)
             if (
-                not data_point.channel.device.client.supports_xml_rpc
+                not data_point.channel.device.client.supports_rpc_callback
                 and data_point.state_path not in self._data_point_path_event_subscriptions
             ):
                 self._data_point_path_event_subscriptions[data_point.state_path] = data_point.dpk
@@ -1970,18 +1972,18 @@ class CentralConfig:
         username: str,
         client_session: ClientSession | None = None,
         callback_host: str | None = None,
-        callback_port: int | None = None,
-        default_callback_port: int = PORT_ANY,
+        callback_port_xml_rpc: int | None = None,
+        default_callback_port_xml_rpc: int = PORT_ANY,
         delay_new_device_creation: bool = DEFAULT_DELAY_NEW_DEVICE_CREATION,
         enable_device_firmware_check: bool = DEFAULT_ENABLE_DEVICE_FIRMWARE_CHECK,
         enable_program_scan: bool = DEFAULT_ENABLE_PROGRAM_SCAN,
         enable_sysvar_scan: bool = DEFAULT_ENABLE_SYSVAR_SCAN,
         hm_master_poll_after_send_intervals: tuple[int, ...] = DEFAULT_HM_MASTER_POLL_AFTER_SEND_INTERVALS,
         ignore_custom_device_definition_models: frozenset[str] = DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
-        interfaces_requiring_periodic_refresh: frozenset[Interface] = INTERFACES_REQUIRING_PERIODIC_REFRESH,
+        interfaces_requiring_periodic_refresh: frozenset[Interface] = DEFAULT_INTERFACES_REQUIRING_PERIODIC_REFRESH,
         json_port: int | None = None,
         listen_ip_addr: str | None = None,
-        listen_port: int | None = None,
+        listen_port_xml_rpc: int | None = None,
         max_read_workers: int = DEFAULT_MAX_READ_WORKERS,
         periodic_refresh_interval: int = DEFAULT_PERIODIC_REFRESH_INTERVAL,
         program_markers: tuple[DescriptionMarker | str, ...] = DEFAULT_PROGRAM_MARKERS,
@@ -1996,11 +1998,14 @@ class CentralConfig:
     ) -> None:
         """Init the client config."""
         self._interface_configs: Final = interface_configs
+        self.requires_xml_rpc_server: Final = any(
+            ic for ic in interface_configs if ic.rpc_server == RpcServerType.XML_RPC
+        )
         self.callback_host: Final = callback_host
-        self.callback_port: Final = callback_port
+        self.callback_port_xml_rpc: Final = callback_port_xml_rpc
         self.central_id: Final = central_id
         self.client_session: Final = client_session
-        self.default_callback_port: Final = default_callback_port
+        self.default_callback_port_xml_rpc: Final = default_callback_port_xml_rpc
         self.delay_new_device_creation: Final = delay_new_device_creation
         self.enable_device_firmware_check: Final = enable_device_firmware_check
         self.enable_program_scan: Final = enable_program_scan
@@ -2011,7 +2016,7 @@ class CentralConfig:
         self.interfaces_requiring_periodic_refresh: Final = frozenset(interfaces_requiring_periodic_refresh or ())
         self.json_port: Final = json_port
         self.listen_ip_addr: Final = listen_ip_addr
-        self.listen_port: Final = listen_port
+        self.listen_port_xml_rpc: Final = listen_port_xml_rpc
         self.max_read_workers = max_read_workers
         self.name: Final = name
         self.password: Final = password
@@ -2028,9 +2033,9 @@ class CentralConfig:
         self.verify_tls: Final = verify_tls
 
     @property
-    def enable_server(self) -> bool:
+    def enable_xml_rpc_server(self) -> bool:
         """Return if server and connection checker should be started."""
-        return self.start_direct is False
+        return self.requires_xml_rpc_server and self.start_direct is False
 
     @property
     def load_un_ignore(self) -> bool:
@@ -2065,7 +2070,7 @@ class CentralConfig:
             password=self.password,
             storage_folder=self.storage_folder,
             callback_host=self.callback_host,
-            callback_port=self.callback_port,
+            callback_port_xml_rpc=self.callback_port_xml_rpc,
             json_port=self.json_port,
             interface_configs=self._interface_configs,
         ):
@@ -2090,9 +2095,9 @@ class CentralConfig:
             url = f"{url}:{self.json_port}"
         return f"{url}"
 
-    def create_json_rpc_client(self, *, central: CentralUnit) -> JsonRpcAioHttpClient:
+    def create_json_rpc_client(self, *, central: CentralUnit) -> AioJsonRpcAioHttpClient:
         """Create a json rpc client."""
-        return JsonRpcAioHttpClient(
+        return AioJsonRpcAioHttpClient(
             username=self.username,
             password=self.password,
             device_url=central.url,
@@ -2109,38 +2114,38 @@ class CentralConnectionState:
     def __init__(self) -> None:
         """Init the CentralConnectionStatus."""
         self._json_issues: Final[list[str]] = []
-        self._xml_proxy_issues: Final[list[str]] = []
+        self._rpc_proxy_issues: Final[list[str]] = []
 
     def add_issue(self, *, issuer: ConnectionProblemIssuer, iid: str) -> bool:
         """Add issue to collection."""
-        if isinstance(issuer, JsonRpcAioHttpClient) and iid not in self._json_issues:
+        if isinstance(issuer, AioJsonRpcAioHttpClient) and iid not in self._json_issues:
             self._json_issues.append(iid)
             _LOGGER.debug("add_issue: add issue  [%s] for JsonRpcAioHttpClient", iid)
             return True
-        if isinstance(issuer, XmlRpcProxy) and iid not in self._xml_proxy_issues:
-            self._xml_proxy_issues.append(iid)
+        if isinstance(issuer, AioXmlRpcProxy) and iid not in self._rpc_proxy_issues:
+            self._rpc_proxy_issues.append(iid)
             _LOGGER.debug("add_issue: add issue [%s] for %s", iid, issuer.interface_id)
             return True
         return False
 
     def remove_issue(self, *, issuer: ConnectionProblemIssuer, iid: str) -> bool:
         """Add issue to collection."""
-        if isinstance(issuer, JsonRpcAioHttpClient) and iid in self._json_issues:
+        if isinstance(issuer, AioJsonRpcAioHttpClient) and iid in self._json_issues:
             self._json_issues.remove(iid)
             _LOGGER.debug("remove_issue: removing issue [%s] for JsonRpcAioHttpClient", iid)
             return True
-        if isinstance(issuer, XmlRpcProxy) and issuer.interface_id in self._xml_proxy_issues:
-            self._xml_proxy_issues.remove(iid)
+        if isinstance(issuer, AioXmlRpcProxy) and issuer.interface_id in self._rpc_proxy_issues:
+            self._rpc_proxy_issues.remove(iid)
             _LOGGER.debug("remove_issue: removing issue [%s] for %s", iid, issuer.interface_id)
             return True
         return False
 
     def has_issue(self, *, issuer: ConnectionProblemIssuer, iid: str) -> bool:
         """Add issue to collection."""
-        if isinstance(issuer, JsonRpcAioHttpClient):
+        if isinstance(issuer, AioJsonRpcAioHttpClient):
             return iid in self._json_issues
-        if isinstance(issuer, XmlRpcProxy):
-            return iid in self._xml_proxy_issues
+        if isinstance(issuer, (AioXmlRpcProxy)):
+            return iid in self._rpc_proxy_issues
 
     def handle_exception_log(
         self,

aiohomematic/central/decorators.py

@@ -12,7 +12,7 @@ import logging
 from typing import Any, Final, cast
 
 from aiohomematic import central as hmcu, client as hmcl
-from aiohomematic.central import xml_rpc_server as xmlrpc
+from aiohomematic.central import rpc_server as rpc
 from aiohomematic.const import BackendSystemEvent
 from aiohomematic.exceptions import AioHomematicException
 from aiohomematic.support import extract_exc_args
@@ -48,7 +48,7 @@ def callback_backend_system(system_event: BackendSystemEvent) -> Callable:
                 central: hmcu.CentralUnit | None = None
                 if isinstance(unit, hmcu.CentralUnit):
                     central = unit
-                if central is None and isinstance(unit, xmlrpc.RPCFunctions):
+                if central is None and isinstance(unit, rpc.RPCFunctions):
                     central = unit.get_central(interface_id=str(args[1]))
                 if central:
                     central.looper.create_task(

aiohomematic/central/{xml_rpc_server.py → rpc_server.py}

@@ -25,14 +25,14 @@ _LOGGER: Final = logging.getLogger(__name__)
 
 # pylint: disable=invalid-name
 class RPCFunctions:
-    """The XML-RPC functions the backend will expect."""
+    """The RPC functions the backend will expect."""
 
-    # Disable kw-only linter for this class since XML-RPC signatures are positional by protocol
+    # Disable kw-only linter
     __kwonly_check__ = False
 
-    def __init__(self, *, xml_rpc_server: XmlRpcServer) -> None:
+    def __init__(self, *, rpc_server: RpcServer) -> None:
         """Init RPCFunctions."""
-        self._xml_rpc_server: Final = xml_rpc_server
+        self._rpc_server: Final = rpc_server
 
     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."""
@@ -50,13 +50,13 @@ 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 backend will send its error message here."""
-        # Structured boundary log (warning level). XML-RPC server received error notification.
+        # Structured boundary log (warning level). RPC server received error notification.
         try:
             raise RuntimeError(str(msg))
         except RuntimeError as err:
             log_boundary_error(
                 logger=_LOGGER,
-                boundary="xml-rpc-server",
+                boundary="rpc-server",
                 action="error",
                 err=err,
                 level=logging.WARNING,
@@ -137,7 +137,7 @@ class RPCFunctions:
 
     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=interface_id)
+        return self._rpc_server.get_central(interface_id=interface_id)
 
 
 # Restrict to specific paths.
@@ -150,7 +150,7 @@ class RequestHandler(SimpleXMLRPCRequestHandler):
     )
 
 
-class AioHomematicXMLRPCServer(SimpleXMLRPCServer):
+class HomematicXMLRPCServer(SimpleXMLRPCServer):
     """
     Simple XML-RPC server.
 
@@ -171,8 +171,8 @@ class AioHomematicXMLRPCServer(SimpleXMLRPCServer):
         return SimpleXMLRPCServer.system_listMethods(self)
 
 
-class XmlRpcServer(threading.Thread):
-    """XML-RPC server thread to handle messages from the backend."""
+class RpcServer(threading.Thread):
+    """RPC server thread to handle messages from the backend."""
 
     _initialized: bool = False
     _instances: Final[dict[tuple[str, int], XmlRpcServer]] = {}
@@ -190,46 +190,30 @@ class XmlRpcServer(threading.Thread):
         self._listen_ip_addr: Final = ip_addr
         self._listen_port: Final[int] = find_free_port() if port == PORT_ANY else port
         self._address: Final[tuple[str, int]] = (ip_addr, self._listen_port)
-        self._instances[self._address] = self
-        threading.Thread.__init__(self, name=f"XmlRpcServer {ip_addr}:{self._listen_port}")
-        self._simple_xml_rpc_server = AioHomematicXMLRPCServer(
-            addr=self._address,
-            requestHandler=RequestHandler,
-            logRequests=False,
-            allow_none=True,
-        )
-        self._simple_xml_rpc_server.register_introspection_functions()
-        self._simple_xml_rpc_server.register_multicall_functions()
-        self._simple_xml_rpc_server.register_instance(RPCFunctions(xml_rpc_server=self), allow_dotted_names=True)
+        threading.Thread.__init__(self, name=f"RpcServer {ip_addr}:{self._listen_port}")
         self._centrals: Final[dict[str, hmcu.CentralUnit]] = {}
-
-    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")
-            return super().__new__(cls)
-        return xml_rpc
+        self._simple_rpc_server: SimpleXMLRPCServer
 
     def run(self) -> None:
-        """Run the XmlRPC-Server thread."""
+        """Run the RPC-Server thread."""
         _LOGGER.debug(
-            "RUN: Starting XmlRPC-Server listening on http://%s:%i",
+            "RUN: Starting RPC-Server listening on %s:%i",
             self._listen_ip_addr,
             self._listen_port,
         )
-        if self._simple_xml_rpc_server:
-            self._simple_xml_rpc_server.serve_forever()
+        if self._simple_rpc_server:
+            self._simple_rpc_server.serve_forever()
 
     def stop(self) -> None:
-        """Stop the XmlRPC-Server."""
-        _LOGGER.debug("STOP: Shutting down XmlRPC-Server")
-        self._simple_xml_rpc_server.shutdown()
-        _LOGGER.debug("STOP: Stopping XmlRPC-Server")
-        self._simple_xml_rpc_server.server_close()
+        """Stop the RPC-Server."""
+        _LOGGER.debug("STOP: Shutting down RPC-Server")
+        self._simple_rpc_server.shutdown()
+        _LOGGER.debug("STOP: Stopping RPC-Server")
+        self._simple_rpc_server.server_close()
         # Ensure the server thread has actually terminated to avoid slow teardown
         with contextlib.suppress(RuntimeError):
             self.join(timeout=1.0)
-        _LOGGER.debug("STOP: XmlRPC-Server stopped")
+        _LOGGER.debug("STOP: RPC-Server stopped")
         if self._address in self._instances:
             del self._instances[self._address]
 
@@ -249,12 +233,12 @@ class XmlRpcServer(threading.Thread):
         return self._started.is_set() is True  # type: ignore[attr-defined]
 
     def add_central(self, *, central: hmcu.CentralUnit) -> None:
-        """Register a central in the XmlRPC-Server."""
+        """Register a central in the RPC-Server."""
         if not self._centrals.get(central.name):
             self._centrals[central.name] = central
 
     def remove_central(self, *, central: hmcu.CentralUnit) -> None:
-        """Unregister a central from XmlRPC-Server."""
+        """Unregister a central from RPC-Server."""
         if self._centrals.get(central.name):
             del self._centrals[central.name]
 
@@ -271,14 +255,45 @@ class XmlRpcServer(threading.Thread):
         return len(self._centrals) == 0
 
 
+class XmlRpcServer(RpcServer):
+    """XML-RPC server thread to handle messages from the backend."""
+
+    def __init__(
+        self,
+        *,
+        ip_addr: str,
+        port: int,
+    ) -> None:
+        """Init XmlRPC server."""
+
+        super().__init__(ip_addr=ip_addr, port=port)
+        self._instances[self._address] = self
+        self._simple_rpc_server = HomematicXMLRPCServer(
+            addr=self._address,
+            requestHandler=RequestHandler,
+            logRequests=False,
+            allow_none=True,
+        )
+        self._simple_rpc_server.register_introspection_functions()
+        self._simple_rpc_server.register_multicall_functions()
+        self._simple_rpc_server.register_instance(RPCFunctions(rpc_server=self), allow_dotted_names=True)
+
+    def __new__(cls, ip_addr: str, port: int) -> XmlRpcServer:  # noqa: PYI034  # kwonly: disable
+        """Create new RPC server."""
+        if (rpc := cls._instances.get((ip_addr, port))) is None:
+            _LOGGER.debug("Creating XmlRpc server")
+            return super().__new__(cls)
+        return rpc
+
+
 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:
-        xml_rpc.start()
+    """Register the rpc server."""
+    rpc = XmlRpcServer(ip_addr=ip_addr, port=port)
+    if not rpc.started:
+        rpc.start()
         _LOGGER.debug(
             "CREATE_XML_RPC_SERVER: Starting XmlRPC-Server listening on %s:%i",
-            xml_rpc.listen_ip_addr,
-            xml_rpc.listen_port,
+            rpc.listen_ip_addr,
+            rpc.listen_port,
         )
-    return xml_rpc
+    return rpc

aiohomematic/client/__init__.py

@@ -56,7 +56,7 @@ from typing import Any, Final, cast
 
 from aiohomematic import central as hmcu
 from aiohomematic.caches.dynamic import CommandCache, PingPongCache
-from aiohomematic.client.xml_rpc import XmlRpcProxy
+from aiohomematic.client.rpc_proxy import AioXmlRpcProxy, BaseRpcProxy
 from aiohomematic.const import (
     CALLBACK_WARN_INTERVAL,
     DATETIME_FORMAT_MILLIS,
@@ -65,8 +65,10 @@ from aiohomematic.const import (
     DP_KEY_VALUE,
     DUMMY_SERIAL,
     INIT_DATETIME,
+    INTERFACE_RPC_SERVER_TYPE,
+    INTERFACES_REQUIRING_JSON_RPC_CLIENT,
     INTERFACES_SUPPORTING_FIRMWARE_UPDATES,
-    INTERFACES_SUPPORTING_XML_RPC,
+    INTERFACES_SUPPORTING_RPC_CALLBACK,
     RECONNECT_WAIT,
     VIRTUAL_REMOTE_MODELS,
     WAIT_FOR_CALLBACK,
@@ -86,6 +88,7 @@ from aiohomematic.const import (
     ProductGroup,
     ProgramData,
     ProxyInitState,
+    RpcServerType,
     SystemInformation,
     SystemVariableData,
 )
@@ -132,7 +135,6 @@ class Client(ABC, LogContextMixin):
     def __init__(self, *, client_config: _ClientConfig) -> None:
         """Initialize the Client."""
         self._config: Final = client_config
-        self._supports_xml_rpc = self.interface in INTERFACES_SUPPORTING_XML_RPC
         self._last_value_send_cache = CommandCache(interface_id=client_config.interface_id)
         self._available: bool = True
         self._connection_error_count: int = 0
@@ -141,8 +143,8 @@ class Client(ABC, LogContextMixin):
         self._ping_pong_cache: Final = PingPongCache(
             central=client_config.central, interface_id=client_config.interface_id
         )
-        self._proxy: XmlRpcProxy
-        self._proxy_read: XmlRpcProxy
+        self._proxy: BaseRpcProxy
+        self._proxy_read: BaseRpcProxy
         self._system_information: SystemInformation
         self.modified_at: datetime = INIT_DATETIME
 
@@ -150,11 +152,16 @@ class Client(ABC, LogContextMixin):
     async def init_client(self) -> None:
         """Init the client."""
         self._system_information = await self._get_system_information()
-        self._proxy = await self._config.create_xml_rpc_proxy(auth_enabled=self.system_information.auth_enabled)
-        self._proxy_read = await self._config.create_xml_rpc_proxy(
-            auth_enabled=self.system_information.auth_enabled,
-            max_workers=self._config.max_read_workers,
-        )
+        if self.supports_rpc_callback:
+            self._proxy = await self._config.create_rpc_proxy(
+                interface=self.interface,
+                auth_enabled=self.system_information.auth_enabled,
+            )
+            self._proxy_read = await self._config.create_rpc_proxy(
+                interface=self.interface,
+                auth_enabled=self.system_information.auth_enabled,
+                max_workers=self._config.max_read_workers,
+            )
 
     @property
     def available(self) -> bool:
@@ -197,9 +204,9 @@ class Client(ABC, LogContextMixin):
         return self._ping_pong_cache
 
     @property
-    def supports_xml_rpc(self) -> bool:
-        """Return if interface support xml rpc."""
-        return self._supports_xml_rpc
+    def supports_rpc_callback(self) -> bool:
+        """Return if interface support rpc callback."""
+        return self._config.supports_rpc_callback
 
     @property
     def system_information(self) -> SystemInformation:
@@ -233,24 +240,24 @@ class Client(ABC, LogContextMixin):
         return ProductGroup.UNKNOWN
 
     @property
-    @abstractmethod
     def supports_ping_pong(self) -> bool:
         """Return the supports_ping_pong info of the backend."""
+        return self.interface in INTERFACES_SUPPORTING_RPC_CALLBACK
 
     @property
     def supports_push_updates(self) -> bool:
         """Return the client supports push update."""
-        return self.interface not in self.central.config.interfaces_requiring_periodic_refresh
+        return self._config.supports_push_updates
 
     @property
     def supports_firmware_updates(self) -> bool:
         """Return the supports_ping_pong info of the backend."""
-        return self.interface in INTERFACES_SUPPORTING_FIRMWARE_UPDATES
+        return self._config.supports_firmware_updates
 
     async def initialize_proxy(self) -> ProxyInitState:
         """Init the proxy has to tell the backend where to send the events."""
 
-        if not self.supports_xml_rpc:
+        if not self.supports_rpc_callback:
             if device_descriptions := await self.list_devices():
                 await self.central.add_new_devices(
                     interface_id=self.interface_id, device_descriptions=device_descriptions
@@ -278,7 +285,7 @@ class Client(ABC, LogContextMixin):
 
     async def deinitialize_proxy(self) -> ProxyInitState:
         """De-init to stop the backend from sending events for this remote."""
-        if not self.supports_xml_rpc:
+        if not self.supports_rpc_callback:
             return ProxyInitState.DE_INIT_SUCCESS
 
         if self.modified_at == INIT_DATETIME:
@@ -348,7 +355,7 @@ class Client(ABC, LogContextMixin):
 
     async def stop(self) -> None:
         """Stop depending services."""
-        if not self.supports_xml_rpc:
+        if not self.supports_rpc_callback:
             return
         await self._proxy.stop()
         await self._proxy_read.stop()
@@ -422,15 +429,17 @@ class Client(ABC, LogContextMixin):
     async def check_connection_availability(self, *, handle_ping_pong: bool) -> bool:
         """Send ping to the backend to generate PONG event."""
 
-    @abstractmethod
     @inspector
     async def execute_program(self, *, pid: str) -> bool:
         """Execute a program on the backend."""
+        _LOGGER.debug("EXECUTE_PROGRAM: not usable for %s.", self.interface_id)
+        return True
 
-    @abstractmethod
     @inspector
     async def set_program_state(self, *, pid: str, state: bool) -> bool:
         """Set the program state on the backend."""
+        _LOGGER.debug("SET_PROGRAM_STATE: not usable for %s.", self.interface_id)
+        return True
 
     @abstractmethod
     @inspector(measure_performance=True)
@@ -454,20 +463,23 @@ class Client(ABC, LogContextMixin):
     ) -> tuple[SystemVariableData, ...] | None:
         """Get all system variables from the backend."""
 
-    @abstractmethod
     @inspector(re_raise=False)
     async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...] | None:
         """Get all programs, if available."""
+        _LOGGER.debug("GET_ALL_PROGRAMS: not usable for %s.", self.interface_id)
+        return None
 
-    @abstractmethod
     @inspector(re_raise=False, no_raise_return={})
     async def get_all_rooms(self) -> dict[str, set[str]]:
         """Get all rooms, if available."""
+        _LOGGER.debug("GET_ALL_ROOMS: not usable for %s.", self.interface_id)
+        return {}
 
-    @abstractmethod
     @inspector(re_raise=False, no_raise_return={})
     async def get_all_functions(self) -> dict[str, set[str]]:
         """Get all functions, if available."""
+        _LOGGER.debug("GET_ALL_FUNCTIONS: not usable for %s.", self.interface_id)
+        return {}
 
     @abstractmethod
     async def _get_system_information(self) -> SystemInformation:
@@ -1094,11 +1106,6 @@ class ClientCCU(Client):
         """Return the model of the backend."""
         return Backend.CCU
 
-    @property
-    def supports_ping_pong(self) -> bool:
-        """Return the supports_ping_pong info of the backend."""
-        return True
-
     @inspector(re_raise=False, measure_performance=True)
     async def fetch_device_details(self) -> None:
         """Get all names via JSON-RPS and store in data.NAMES."""
@@ -1252,23 +1259,13 @@ class ClientCCU(Client):
 
 
 class ClientJsonCCU(ClientCCU):
-    """Client implementation for CCU-like backend (CCU-Jack, CuXD)."""
-
-    @inspector
-    async def init_client(self) -> None:
-        """Init the client."""
-        self._system_information = await self._get_system_information()
+    """Client implementation for CCU-like backend (CCU-Jack)."""
 
     @inspector(re_raise=False, no_raise_return=False)
     async def check_connection_availability(self, *, handle_ping_pong: bool) -> bool:
         """Check if proxy is still initialized."""
         return await self._json_rpc_client.is_present(interface=self.interface)
 
-    @property
-    def supports_ping_pong(self) -> bool:
-        """Return the supports_ping_pong info of the backend."""
-        return False
-
     @inspector(re_raise=False)
     async def get_device_description(self, *, device_address: str) -> DeviceDescription | None:
         """Get device descriptions from the backend."""
@@ -1401,7 +1398,7 @@ class ClientJsonCCU(ClientCCU):
                 channel_address=channel_address, parameter=parameter, value=value, rx_mode=rx_mode
             )
 
-        # Funktioniert nicht
+        # Doesn't work. put_paramset not supported
         #     if (
         #         value_type := self._get_parameter_type(
         #             channel_address=channel_address,
@@ -1459,6 +1456,52 @@ class ClientJsonCCU(ClientCCU):
             serial=f"{self.interface}_{DUMMY_SERIAL}",
         )
 
+    @inspector
+    async def add_link(self, *, sender_address: str, receiver_address: str, name: str, description: str) -> None:
+        """Return a list of links."""
+        _LOGGER.debug("ADD_LINK: not usable for %s.", self.interface_id)
+
+    @inspector
+    async def remove_link(self, *, sender_address: str, receiver_address: str) -> None:
+        """Return a list of links."""
+        _LOGGER.debug("REMOVE_LINK: not usable for %s.", self.interface_id)
+
+    @inspector
+    async def get_link_peers(self, *, address: str) -> tuple[str, ...] | None:
+        """Return a list of link pers."""
+        _LOGGER.debug("GET_LINK_PEERS: not usable for %s.", self.interface_id)
+        return None
+
+    @inspector
+    async def get_links(self, *, address: str, flags: int) -> dict[str, Any]:
+        """Return a list of links."""
+        _LOGGER.debug("GET_LINKS: not usable for %s.", self.interface_id)
+        return {}
+
+    @inspector
+    async def get_metadata(self, *, address: str, data_id: str) -> dict[str, Any]:
+        """Return the metadata for an object."""
+        _LOGGER.debug("GET_METADATA: not usable for %s.", self.interface_id)
+        return {}
+
+    @inspector
+    async def set_metadata(self, *, address: str, data_id: str, value: dict[str, Any]) -> dict[str, Any]:
+        """Write the metadata for an object."""
+        _LOGGER.debug("SET_METADATA: not usable for %s.", self.interface_id)
+        return {}
+
+    @inspector
+    async def report_value_usage(self, *, address: str, value_id: str, ref_counter: int) -> bool:
+        """Report value usage."""
+        _LOGGER.debug("REPORT_VALUE_USAGE: not usable for %s.", self.interface_id)
+        return True
+
+    @inspector
+    async def update_device_firmware(self, *, device_address: str) -> bool:
+        """Update the firmware of a Homematic device."""
+        _LOGGER.debug("UPDATE_DEVICE_FIRMWARE: not usable for %s.", self.interface_id)
+        return True
+
 
 class ClientHomegear(Client):
     """Client implementation for Homegear backend."""
@@ -1515,16 +1558,6 @@ class ClientHomegear(Client):
         self.modified_at = INIT_DATETIME
         return False
 
-    @inspector
-    async def execute_program(self, *, pid: str) -> bool:
-        """Execute a program on the backend."""
-        return True
-
-    @inspector
-    async def set_program_state(self, *, pid: str, state: bool) -> bool:
-        """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 the backend."""
@@ -1553,21 +1586,6 @@ class ClientHomegear(Client):
                 variables.append(SystemVariableData(vid=name, legacy_name=name, value=value))
         return tuple(variables)
 
-    @inspector(re_raise=False)
-    async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...] | None:
-        """Get all programs, if available."""
-        return ()
-
-    @inspector(re_raise=False, no_raise_return={})
-    async def get_all_rooms(self) -> dict[str, set[str]]:
-        """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 the backend."""
-        return {}
-
     async def _get_system_information(self) -> SystemInformation:
         """Get system information of the backend."""
         return SystemInformation(available_interfaces=(Interface.BIDCOS_RF,), serial=f"{self.interface}_{DUMMY_SERIAL}")
@@ -1590,9 +1608,20 @@ class _ClientConfig:
         self.interface_id: Final = interface_config.interface_id
         self.max_read_workers: Final[int] = central.config.max_read_workers
         self.has_credentials: Final[bool] = central.config.username is not None and central.config.password is not None
-        self.init_url: Final[str] = f"http://{
+        self.supports_firmware_updates: Final = self.interface in INTERFACES_SUPPORTING_FIRMWARE_UPDATES
+        self.supports_push_updates: Final = self.interface not in central.config.interfaces_requiring_periodic_refresh
+        self.supports_rpc_callback: Final = self.interface in INTERFACES_SUPPORTING_RPC_CALLBACK
+        callback_host: Final = (
             central.config.callback_host if central.config.callback_host else central.callback_ip_addr
-        }:{central.config.callback_port if central.config.callback_port else central.listen_port}"
+        )
+        callback_port = (
+            central.config.callback_port_xml_rpc
+            if central.config.callback_port_xml_rpc
+            else central.listen_port_xml_rpc
+        )
+        init_url = f"{callback_host}:{callback_port}"
+        self.init_url: Final = f"http://{init_url}"
+
         self.xml_rpc_uri: Final = build_xml_rpc_uri(
             host=central.config.host,
             port=interface_config.port,
@@ -1607,7 +1636,7 @@ class _ClientConfig:
             client: Client | None
             if self.interface == Interface.BIDCOS_RF and ("Homegear" in self.version or "pydevccu" in self.version):
                 client = ClientHomegear(client_config=self)
-            elif self.interface in (Interface.CCU_JACK, Interface.CUXD):
+            elif self.interface in INTERFACES_REQUIRING_JSON_RPC_CLIENT:
                 client = ClientJsonCCU(client_config=self)
             else:
                 client = ClientCCU(client_config=self)
@@ -1624,9 +1653,9 @@ class _ClientConfig:
 
     async def _get_version(self) -> str:
         """Return the version of the the backend."""
-        if self.interface in (Interface.CCU_JACK, Interface.CUXD):
+        if self.interface in INTERFACES_REQUIRING_JSON_RPC_CLIENT:
             return "0"
-        check_proxy = await self._create_simple_xml_rpc_proxy()
+        check_proxy = await self._create_simple_rpc_proxy(interface=self.interface)
         try:
             if (methods := check_proxy.supported_methods) and "getVersion" in methods:
                 # BidCos-Wired does not support getVersion()
@@ -1635,9 +1664,14 @@ class _ClientConfig:
             raise NoConnectionException(f"Unable to connect {extract_exc_args(exc=exc)}.") from exc
         return "0"
 
-    async def create_xml_rpc_proxy(
+    async def create_rpc_proxy(
+        self, *, interface: Interface, auth_enabled: bool | None = None, max_workers: int = DEFAULT_MAX_WORKERS
+    ) -> BaseRpcProxy:
+        return await self._create_xml_rpc_proxy(auth_enabled=auth_enabled, max_workers=max_workers)
+
+    async def _create_xml_rpc_proxy(
         self, *, auth_enabled: bool | None = None, max_workers: int = DEFAULT_MAX_WORKERS
-    ) -> XmlRpcProxy:
+    ) -> AioXmlRpcProxy:
         """Return a XmlRPC proxy for the backend communication."""
         config = self.central.config
         xml_rpc_headers = (
@@ -1648,7 +1682,7 @@ class _ClientConfig:
             if auth_enabled
             else []
         )
-        xml_proxy = XmlRpcProxy(
+        xml_proxy = AioXmlRpcProxy(
             max_workers=max_workers,
             interface_id=self.interface_id,
             connection_state=self.central.connection_state,
@@ -1660,9 +1694,13 @@ class _ClientConfig:
         await xml_proxy.do_init()
         return xml_proxy
 
-    async def _create_simple_xml_rpc_proxy(self) -> XmlRpcProxy:
+    async def _create_simple_rpc_proxy(self, *, interface: Interface) -> BaseRpcProxy:
+        """Return a RPC proxy for the backend communication."""
+        return await self._create_xml_rpc_proxy()
+
+    async def _create_simple_xml_rpc_proxy(self) -> AioXmlRpcProxy:
         """Return a XmlRPC proxy for the backend communication."""
-        return await self.create_xml_rpc_proxy(auth_enabled=True, max_workers=0)
+        return await self._create_xml_rpc_proxy(auth_enabled=True, max_workers=0)
 
 
 class InterfaceConfig:
@@ -1673,11 +1711,13 @@ class InterfaceConfig:
         *,
         central_name: str,
         interface: Interface,
-        port: int | None = None,
+        port: int,
         remote_path: str | None = None,
     ) -> None:
         """Init the interface config."""
         self.interface: Final[Interface] = interface
+
+        self.rpc_server: Final[RpcServerType] = INTERFACE_RPC_SERVER_TYPE[interface]
         self.interface_id: Final[str] = f"{central_name}-{self.interface}"
         self.port: Final = port
         self.remote_path: Final = remote_path
@@ -1686,7 +1726,7 @@ class InterfaceConfig:
 
     def _init_validate(self) -> None:
         """Validate the client_config."""
-        if not self.port and self.interface in INTERFACES_SUPPORTING_XML_RPC:
+        if not self.port and self.interface in INTERFACES_SUPPORTING_RPC_CALLBACK:
             raise ClientException(f"VALIDATE interface config failed: Port must defined for interface{self.interface}")
 
     @property

aiohomematic/client/json_rpc.py

@@ -179,7 +179,7 @@ _PARALLEL_EXECUTION_LIMITED_JSONRPC_METHODS: Final = (
 )
 
 
-class JsonRpcAioHttpClient(LogContextMixin):
+class AioJsonRpcAioHttpClient(LogContextMixin):
     """Connection to CCU JSON-RPC Server."""
 
     def __init__(

aiohomematic/client/{xml_rpc.py → rpc_proxy.py}

@@ -21,13 +21,14 @@ Notes
 
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 import asyncio
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from concurrent.futures import ThreadPoolExecutor
 from enum import Enum, IntEnum, StrEnum
 import errno
 import logging
-from ssl import SSLError
+from ssl import SSLContext, SSLError
 from typing import Any, Final
 import xmlrpc.client
 
@@ -51,7 +52,7 @@ _TLS: Final = "tls"
 _VERIFY_TLS: Final = "verify_tls"
 
 
-class _XmlRpcMethod(StrEnum):
+class _RpcMethod(StrEnum):
     """Enum for Homematic json rpc methods types."""
 
     GET_VERSION = "getVersion"
@@ -61,12 +62,12 @@ class _XmlRpcMethod(StrEnum):
     SYSTEM_LIST_METHODS = "system.listMethods"
 
 
-_VALID_XMLRPC_COMMANDS_ON_NO_CONNECTION: Final[tuple[str, ...]] = (
-    _XmlRpcMethod.GET_VERSION,
-    _XmlRpcMethod.HOMEGEAR_INIT,
-    _XmlRpcMethod.INIT,
-    _XmlRpcMethod.PING,
-    _XmlRpcMethod.SYSTEM_LIST_METHODS,
+_VALID_RPC_COMMANDS_ON_NO_CONNECTION: Final[tuple[str, ...]] = (
+    _RpcMethod.GET_VERSION,
+    _RpcMethod.HOMEGEAR_INIT,
+    _RpcMethod.INIT,
+    _RpcMethod.PING,
+    _RpcMethod.SYSTEM_LIST_METHODS,
 )
 
 _SSL_ERROR_CODES: Final[dict[int, str]] = {
@@ -83,7 +84,7 @@ _OS_ERROR_CODES: Final[dict[int, str]] = {
 
 
 # noinspection PyProtectedMember,PyUnresolvedReferences
-class XmlRpcProxy(xmlrpc.client.ServerProxy):
+class BaseRpcProxy(ABC):
     """ServerProxy implementation with ThreadPoolExecutor when request is executing."""
 
     def __init__(
@@ -92,59 +93,96 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy):
         max_workers: int,
         interface_id: str,
         connection_state: hmcu.CentralConnectionState,
-        uri: str,
-        headers: list[tuple[str, str]],
+        magic_method: Callable,
         tls: bool = False,
         verify_tls: bool = False,
     ) -> None:
         """Initialize new proxy for server and get local ip."""
         self._interface_id: Final = interface_id
         self._connection_state: Final = connection_state
+        self._magic_method: Final = magic_method
         self._looper: Final = Looper()
         self._proxy_executor: Final = (
             ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix=interface_id) if max_workers > 0 else None
         )
-        self._tls: Final[bool] = tls
-        self._verify_tls: Final[bool] = verify_tls
+        self._tls: Final[bool | SSLContext] = get_tls_context(verify_tls=verify_tls) if tls else False
         self._supported_methods: tuple[str, ...] = ()
-        kwargs: dict[str, Any] = {}
-        if self._tls:
-            kwargs[_CONTEXT] = get_tls_context(verify_tls=self._verify_tls)
+        self._kwargs: dict[str, Any] = {}
+        if tls:
+            self._kwargs[_CONTEXT] = self._tls
         # Due to magic method the log_context must be defined manually.
-        self.log_context: Final[Mapping[str, Any]] = {"interface_id": self._interface_id, "tls": self._tls}
-        xmlrpc.client.ServerProxy.__init__(
-            self,
-            uri=uri,
-            encoding=ISO_8859_1,
-            headers=headers,
-            **kwargs,
-        )
+        self.log_context: Final[Mapping[str, Any]] = {"interface_id": self._interface_id, "tls": tls}
 
+    @abstractmethod
     async def do_init(self) -> None:
-        """Init the xml rpc proxy."""
-        if supported_methods := await self.system.listMethods():
-            # ping is missing in VirtualDevices interface but can be used.
-            supported_methods.append(_XmlRpcMethod.PING)
-            self._supported_methods = tuple(supported_methods)
+        """Init the rpc proxy."""
 
     @property
     def supported_methods(self) -> tuple[str, ...]:
         """Return the supported methods."""
         return self._supported_methods
 
-    async def __async_request(self, *args, **kwargs):  # type: ignore[no-untyped-def]
+    async def stop(self) -> None:
+        """Stop depending services."""
+        await self._looper.block_till_done()
+        if self._proxy_executor:
+            self._proxy_executor.shutdown()
+
+    @abstractmethod
+    async def _async_request(self, *args, **kwargs):  # type: ignore[no-untyped-def]
+        """Call method on server side."""
+
+    def __getattr__(self, *args, **kwargs):  # type: ignore[no-untyped-def]
+        """Magic method dispatcher."""
+        return self._magic_method(self._async_request, *args, **kwargs)
+
+
+# noinspection PyProtectedMember,PyUnresolvedReferences
+class AioXmlRpcProxy(BaseRpcProxy, xmlrpc.client.ServerProxy):
+    """ServerProxy implementation with ThreadPoolExecutor when request is executing."""
+
+    def __init__(
+        self,
+        *,
+        max_workers: int,
+        interface_id: str,
+        connection_state: hmcu.CentralConnectionState,
+        uri: str,
+        headers: list[tuple[str, str]],
+        tls: bool = False,
+        verify_tls: bool = False,
+    ) -> None:
+        """Initialize new proxy for server and get local ip."""
+        super().__init__(
+            max_workers=max_workers,
+            interface_id=interface_id,
+            connection_state=connection_state,
+            magic_method=xmlrpc.client._Method,
+            tls=tls,
+            verify_tls=verify_tls,
+        )
+
+        xmlrpc.client.ServerProxy.__init__(
+            self,
+            uri=uri,
+            encoding=ISO_8859_1,
+            headers=headers,
+            **self._kwargs,
+        )
+
+    async def _async_request(self, *args, **kwargs):  # type: ignore[no-untyped-def]
         """Call method on server side."""
         parent = xmlrpc.client.ServerProxy
         try:
             method = args[0]
             if self._supported_methods and method not in self._supported_methods:
-                raise UnsupportedException(f"__ASYNC_REQUEST: method '{method} not supported by the backend.")
+                raise UnsupportedException(f"XmlRPC.__ASYNC_REQUEST: method '{method} not supported by the backend.")
 
-            if method in _VALID_XMLRPC_COMMANDS_ON_NO_CONNECTION or not self._connection_state.has_issue(
+            if method in _VALID_RPC_COMMANDS_ON_NO_CONNECTION or not self._connection_state.has_issue(
                 issuer=self, iid=self._interface_id
             ):
                 args = _cleanup_args(*args)
-                _LOGGER.debug("__ASYNC_REQUEST: %s", args)
+                _LOGGER.debug("XmlRPC.__ASYNC_REQUEST: %s", args)
                 result = await asyncio.shield(
                     self._looper.async_add_executor_job(
                         # pylint: disable=protected-access
@@ -212,15 +250,12 @@ class XmlRpcProxy(xmlrpc.client.ServerProxy):
         except Exception as exc:
             raise ClientException(exc) from exc
 
-    def __getattr__(self, *args, **kwargs):  # type: ignore[no-untyped-def]
-        """Magic method dispatcher."""
-        return xmlrpc.client._Method(self.__async_request, *args, **kwargs)
-
-    async def stop(self) -> None:
-        """Stop depending services."""
-        await self._looper.block_till_done()
-        if self._proxy_executor:
-            self._proxy_executor.shutdown()
+    async def do_init(self) -> None:
+        """Init the xml rpc proxy."""
+        if supported_methods := await self.system.listMethods():
+            # ping is missing in VirtualDevices interface but can be used.
+            supported_methods.append(_RpcMethod.PING)
+            self._supported_methods = tuple(supported_methods)
 
 
 def _cleanup_args(*args: Any) -> Any:

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.4"
+VERSION: Final = "2025.10.6"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -573,6 +573,13 @@ class ParameterType(StrEnum):
     EMPTY = ""
 
 
+class RpcServerType(StrEnum):
+    """Enum for Homematic rpc server types."""
+
+    XML_RPC = "xml_rpc"
+    NONE = "none"
+
+
 CLICK_EVENTS: Final[frozenset[Parameter]] = frozenset(
     {
         Parameter.PRESS,
@@ -689,7 +696,7 @@ INTERFACES_SUPPORTING_FIRMWARE_UPDATES: Final[frozenset[Interface]] = frozenset(
     }
 )
 
-INTERFACES_SUPPORTING_XML_RPC: Final[frozenset[Interface]] = frozenset(
+INTERFACES_REQUIRING_XML_RPC: Final[frozenset[Interface]] = frozenset(
     {
         Interface.BIDCOS_RF,
         Interface.BIDCOS_WIRED,
@@ -698,13 +705,33 @@ INTERFACES_SUPPORTING_XML_RPC: Final[frozenset[Interface]] = frozenset(
     }
 )
 
-INTERFACES_REQUIRING_PERIODIC_REFRESH: Final[frozenset[Interface]] = frozenset(
+
+INTERFACES_SUPPORTING_RPC_CALLBACK: Final[frozenset[Interface]] = frozenset(INTERFACES_REQUIRING_XML_RPC)
+
+
+INTERFACES_REQUIRING_JSON_RPC_CLIENT: Final[frozenset[Interface]] = frozenset(
     {
-        Interface.CCU_JACK,
         Interface.CUXD,
+        Interface.CCU_JACK,
     }
 )
 
+DEFAULT_INTERFACES_REQUIRING_PERIODIC_REFRESH: Final[frozenset[Interface]] = frozenset(
+    INTERFACES_REQUIRING_JSON_RPC_CLIENT - INTERFACES_REQUIRING_XML_RPC
+)
+
+INTERFACE_RPC_SERVER_TYPE: Final[Mapping[Interface, RpcServerType]] = MappingProxyType(
+    {
+        Interface.BIDCOS_RF: RpcServerType.XML_RPC,
+        Interface.BIDCOS_WIRED: RpcServerType.XML_RPC,
+        Interface.HMIP_RF: RpcServerType.XML_RPC,
+        Interface.VIRTUAL_DEVICES: RpcServerType.XML_RPC,
+        Interface.CUXD: RpcServerType.NONE,
+        Interface.CCU_JACK: RpcServerType.NONE,
+    }
+)
+
+
 DEFAULT_USE_PERIODIC_SCAN_FOR_INTERFACES: Final = True
 
 IGNORE_FOR_UN_IGNORE_PARAMETERS: Final[frozenset[Parameter]] = frozenset(

aiohomematic/model/custom/switch.py

@@ -110,6 +110,7 @@ def make_ip_switch(
 # HomeBrew (HB-) devices are always listed as HM-.
 DEVICES: Mapping[str, CustomConfig | tuple[CustomConfig, ...]] = {
     "ELV-SH-BS2": CustomConfig(make_ce_func=make_ip_switch, channels=(4, 8)),
+    "ELV-SH-PSMCI": CustomConfig(make_ce_func=make_ip_switch, channels=(3,)),
     "ELV-SH-SW1-BAT": CustomConfig(make_ce_func=make_ip_switch, channels=(3,)),
     "HmIP-BS2": CustomConfig(make_ce_func=make_ip_switch, channels=(4, 8)),
     "HmIP-BSL": CustomConfig(make_ce_func=make_ip_switch, channels=(4,)),

aiohomematic/support.py

@@ -100,7 +100,7 @@ def check_config(
     password: str,
     storage_folder: str,
     callback_host: str | None,
-    callback_port: int | None,
+    callback_port_xml_rpc: int | None,
     json_port: int | None,
     interface_configs: AbstractSet[hmcl.InterfaceConfig] | None = None,
 ) -> list[str]:
@@ -123,8 +123,8 @@ def check_config(
         config_failures.append(extract_exc_args(exc=bhexc)[0])
     if callback_host and not (is_hostname(hostname=callback_host) or is_ipv4_address(address=callback_host)):
         config_failures.append("Invalid callback hostname or ipv4 address")
-    if callback_port and not is_port(port=callback_port):
-        config_failures.append("Invalid callback port")
+    if callback_port_xml_rpc and not is_port(port=callback_port_xml_rpc):
+        config_failures.append("Invalid xml rpc callback port")
     if json_port and not is_port(port=json_port):
         config_failures.append("Invalid json port")
     if interface_configs and not has_primary_client(interface_configs=interface_configs):
@@ -174,7 +174,7 @@ def extract_device_addresses_from_device_descriptions(
         {
             parent_address
             for dev_desc in device_descriptions
-            if (parent_address := dev_desc["PARENT"]) is not None and (is_device_address(address=parent_address))
+            if (parent_address := dev_desc.get("PARENT")) and (is_device_address(address=parent_address))
         }
     )
 

{aiohomematic-2025.10.4.dist-info → aiohomematic-2025.10.6.dist-info}/METADATA

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

{aiohomematic-2025.10.4.dist-info → aiohomematic-2025.10.6.dist-info}/RECORD

@@ -1,6 +1,6 @@
 aiohomematic/__init__.py,sha256=ngULK_anZQwwUUCVcberBdVjguYfboiuG9VoueKy9fA,2283
 aiohomematic/async_support.py,sha256=BeNKaDrFsRA5-_uAFzmyyKPqlImfSs58C22Nqd5dZAg,7887
-aiohomematic/const.py,sha256=VDLTURjQcPRA2F_A10jED7tuGuE9ZZZtCAbphjLNhNY,25840
+aiohomematic/const.py,sha256=7siFMot4SYI6EAdWTG-GTgsHsdYpue_0EA-29kyBEbk,26643
 aiohomematic/context.py,sha256=M7gkA7KFT0dp35gzGz2dzKVXu1PP0sAnepgLlmjyRS4,451
 aiohomematic/converter.py,sha256=gaNHe-WEiBStZMuuRz9iGn3Mo_CGz1bjgLtlYBJJAko,3624
 aiohomematic/decorators.py,sha256=M4n_VSyqmsUgQQQv_-3JWQxYPbS6KEkhCS8OzAfaVKo,11060
@@ -8,19 +8,19 @@ aiohomematic/exceptions.py,sha256=8Uu3rADawhYlAz6y4J52aJ-wKok8Z7YbUYUwWeGMKhs,50
 aiohomematic/hmcli.py,sha256=qNstNDX6q8t3mJFCGlXlmRVobGabntrPtFi3kchf1Eg,4933
 aiohomematic/property_decorators.py,sha256=56lHGATgRtaFkIK_IXcR2tBW9mIVITcCwH5KOw575GA,17162
 aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic/support.py,sha256=8sZtyPKh9sSv0dA3dAlTCCsq0UUl6g49-oqka2Coa1s,22810
+aiohomematic/support.py,sha256=7FTIDvRZvGFMfN3i_zBnHtJQd-vDqTMTq2i1G5GmW3Y,22834
 aiohomematic/validator.py,sha256=HUikmo-SFksehFBAdZmBv4ajy0XkjgvXvcCfbexnzZo,3563
 aiohomematic/caches/__init__.py,sha256=_gI30tbsWgPRaHvP6cRxOQr6n9bYZzU-jp1WbHhWg-A,470
 aiohomematic/caches/dynamic.py,sha256=0hOu-WoYUc9_3fofMeg_OjlYS-quD4uTyDI6zd5W4Do,22553
 aiohomematic/caches/persistent.py,sha256=xUMjvu5Vthz9W0LLllSbcqTADZvVV025b4VnPzrPnis,20604
-aiohomematic/caches/visibility.py,sha256=SThfEO3LKbIIERD4Novyj4ZZUkcYrBuvYdNQfPO29JQ,31676
-aiohomematic/central/__init__.py,sha256=i2jX_6nWAP59UmssCfbB0dN3DcHIlncpxW8enDinsDA,92211
-aiohomematic/central/decorators.py,sha256=v0gCa5QEQPNEvGy0O2YIOhoJy7OKiJZJWtK64OQm7y4,6918
-aiohomematic/central/xml_rpc_server.py,sha256=1Vr8BXakLSo-RC967IlRI9LPUCl4iXp2y-AXSZuDyPc,10777
-aiohomematic/client/__init__.py,sha256=KcqPEsqYF6L5RoW3LoKd83GqyM2F8W6LkA_cBG_sLiw,71519
+aiohomematic/caches/visibility.py,sha256=8lTO-jfAUzd90atUOK8rKMrzRa__m083RAoEovg0Q0o,31676
+aiohomematic/central/__init__.py,sha256=_ft-2HXfn0pF_LTrNyV_mZ7cHkHuRgeprBJZx5MlK0I,92659
+aiohomematic/central/decorators.py,sha256=NUMSsQ_Or6gno4LzagrNMXeBtmbBbYyoIlMI0TFp1_E,6908
+aiohomematic/central/rpc_server.py,sha256=V1H8RNs8ofDOXe_L0yK_GXA7N-39sp3NcywPWzHcJnQ,10899
+aiohomematic/client/__init__.py,sha256=w7ns0JZNroKNy9Yw1YM1ssxhPwXUoVNpPo5RLAbgK7E,73857
 aiohomematic/client/_rpc_errors.py,sha256=-NPtGvkQPJ4V2clDxv1tKy09M9JZm61pUCeki9DDh6s,2984
-aiohomematic/client/json_rpc.py,sha256=DSTmKB7YdxVmOH5b7HKoN_H-fI837n0CpyPdJyurans,50174
-aiohomematic/client/xml_rpc.py,sha256=9PEOWoTG0EMUAMyqiInF4iA_AduHv_hhjJW3YhYjYqU,9614
+aiohomematic/client/json_rpc.py,sha256=7p8j6uhS0y2LuJVtobQqwtpOA_AsC5HqEdGB0T8ZSu4,50177
+aiohomematic/client/rpc_proxy.py,sha256=v0YyhfQ_qylQpqGvGtylJtG3_tIk9PN6tWMHkki4D48,10705
 aiohomematic/model/__init__.py,sha256=KO7gas_eEzm67tODKqWTs0617CSGeKKjOWOlDbhRo_Q,5458
 aiohomematic/model/data_point.py,sha256=Ml8AOQ1RcRezTYWiGBlIXwcTLolQMX5Cyb-O7GtNDm4,41586
 aiohomematic/model/device.py,sha256=15z5G2X3jSJaj-yz7jX_tnirzipRIGBJPymObY3Dmjk,52942
@@ -42,7 +42,7 @@ aiohomematic/model/custom/light.py,sha256=2UxQOoupwTpQ-5iwY51gL_B815sgDXNW-HG-Qh
 aiohomematic/model/custom/lock.py,sha256=ndzZ0hp7FBohw7T_qR0jPobwlcwxus9M1DuDu_7vfPw,11996
 aiohomematic/model/custom/siren.py,sha256=DT8RoOCl7FqstgRSBK-RWRcY4T29LuEdnlhaWCB6ATk,9785
 aiohomematic/model/custom/support.py,sha256=UvencsvCwgpm4iqRNRt5KRs560tyw1NhYP5ZaqmCT2k,1453
-aiohomematic/model/custom/switch.py,sha256=VKknWPJOtSwIzV-Ag_8Zg1evtkyjKh768Be_quU_R54,6885
+aiohomematic/model/custom/switch.py,sha256=tIAd501_yqQB9dd1pcTTmF7tEhFqqj3gfcSgBYN_2_8,6963
 aiohomematic/model/custom/valve.py,sha256=u9RYzeJ8FNmpFO6amlLElXTQdAeqac5yo7NbZYS6Z9U,4242
 aiohomematic/model/generic/__init__.py,sha256=-ho8m9gFlORBGNPn2i8c9i5-GVLLFvTlf5FFpaTJbFw,7675
 aiohomematic/model/generic/action.py,sha256=niJPvTs43b9GiKomdBaBKwjOwtmNxR_YRhj5Fpje9NU,997
@@ -69,10 +69,10 @@ aiohomematic/rega_scripts/get_serial.fn,sha256=t1oeo-sB_EuVeiY24PLcxFSkdQVgEWGXz
 aiohomematic/rega_scripts/get_system_variable_descriptions.fn,sha256=UKXvC0_5lSApdQ2atJc0E5Stj5Zt3lqh0EcliokYu2c,849
 aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m04cHjVj4kIOnUUgpY,279
 aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
-aiohomematic-2025.10.4.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic-2025.10.6.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
 aiohomematic_support/__init__.py,sha256=_0YtF4lTdC_k6-zrM2IefI0u0LMr_WA61gXAyeGLgbY,66
 aiohomematic_support/client_local.py,sha256=nFeYkoX_EXXIwbrpL_5peYQG-934D0ASN6kflYp0_4I,12819
-aiohomematic-2025.10.4.dist-info/METADATA,sha256=4PozhxhfpJbt0vBqnm_ZWxwuU46sJcp91I7SBrYG-Kg,7603
-aiohomematic-2025.10.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.4.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
-aiohomematic-2025.10.4.dist-info/RECORD,,
+aiohomematic-2025.10.6.dist-info/METADATA,sha256=IjdBD7NWGknN0DlQcM0K4gZeFEYAkC-iCnUOkRPu1tU,7603
+aiohomematic-2025.10.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.6.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
+aiohomematic-2025.10.6.dist-info/RECORD,,