aiohomematic 2025.10.4__tar.gz → 2025.10.6__tar.gz

{aiohomematic-2025.10.4 → aiohomematic-2025.10.6}/PKG-INFO

@@ -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 → aiohomematic-2025.10.6}/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-2025.10.4 → aiohomematic-2025.10.6}/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-2025.10.4 → aiohomematic-2025.10.6}/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-2025.10.4/aiohomematic/central/xml_rpc_server.py → aiohomematic-2025.10.6/aiohomematic/central/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