aiohomematic 2025.10.10__py3-none-any.whl → 2025.10.11__py3-none-any.whl

aiohomematic/central/rpc_server.py

@@ -18,7 +18,7 @@ from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
 from aiohomematic import central as hmcu
 from aiohomematic.central.decorators import callback_backend_system
 from aiohomematic.const import IP_ANY_V4, PORT_ANY, BackendSystemEvent
-from aiohomematic.support import find_free_port, log_boundary_error
+from aiohomematic.support import log_boundary_error
 
 _LOGGER: Final = logging.getLogger(__name__)
 
@@ -177,23 +177,19 @@ class RpcServer(threading.Thread):
     _initialized: bool = False
     _instances: Final[dict[tuple[str, int], RpcServer]] = {}
 
-    def __init__(
-        self,
-        *,
-        ip_addr: str,
-        port: int,
-    ) -> None:
+    def __init__(self, *, server: SimpleXMLRPCServer) -> None:
         """Init XmlRPC server."""
-        if self._initialized:
-            return
+        self._server = server
+        self._server.register_introspection_functions()
+        self._server.register_multicall_functions()
+        self._server.register_instance(RPCFunctions(rpc_server=self), allow_dotted_names=True)
         self._initialized = True
-        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._address: Final[tuple[str, int]] = cast(tuple[str, int], server.server_address)
+        self._listen_ip_addr: Final = self._address[0]
+        self._listen_port: Final = self._address[1]
         self._centrals: Final[dict[str, hmcu.CentralUnit]] = {}
-        self._simple_rpc_server: SimpleXMLRPCServer
         self._instances[self._address] = self
-        threading.Thread.__init__(self, name=f"RpcServer {ip_addr}:{self._listen_port}")
+        threading.Thread.__init__(self, name=f"RpcServer {self._listen_ip_addr}:{self._listen_port}")
 
     def run(self) -> None:
         """Run the RPC-Server thread."""
@@ -202,15 +198,15 @@ class RpcServer(threading.Thread):
             self._listen_ip_addr,
             self._listen_port,
         )
-        if self._simple_rpc_server:
-            self._simple_rpc_server.serve_forever()
+        if self._server:
+            self._server.serve_forever()
 
     def stop(self) -> None:
         """Stop the RPC-Server."""
         _LOGGER.debug("STOP: Shutting down RPC-Server")
-        self._simple_rpc_server.shutdown()
+        self._server.shutdown()
         _LOGGER.debug("STOP: Stopping RPC-Server")
-        self._simple_rpc_server.server_close()
+        self._server.server_close()
         # Ensure the server thread has actually terminated to avoid slow teardown
         with contextlib.suppress(RuntimeError):
             self.join(timeout=1.0)
@@ -269,16 +265,14 @@ class XmlRpcServer(RpcServer):
 
         if self._initialized:
             return
-        super().__init__(ip_addr=ip_addr, port=port)
-        self._simple_rpc_server = HomematicXMLRPCServer(
-            addr=self._address,
-            requestHandler=RequestHandler,
-            logRequests=False,
-            allow_none=True,
+        super().__init__(
+            server=HomematicXMLRPCServer(
+                addr=(ip_addr, port),
+                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."""

aiohomematic/client/json_rpc.py

@@ -368,8 +368,8 @@ class AioJsonRpcAioHttpClient(LogContextMixin):
         _LOGGER.debug("POST_SCRIPT: method: %s [%s]", method, script_name)
 
         try:
-            if not response[_JsonKey.ERROR]:
-                response[_JsonKey.RESULT] = orjson.loads(response[_JsonKey.RESULT])
+            if not response[_JsonKey.ERROR] and (resp := response[_JsonKey.RESULT]) and isinstance(resp, str):
+                response[_JsonKey.RESULT] = orjson.loads(resp)
         finally:
             if not keep_session:
                 await self._do_logout(session_id=session_id)

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.10"
+VERSION: Final = "2025.10.11"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -41,7 +41,7 @@ DEFAULT_MULTIPLIER: Final = 1.0
 DEFAULT_OPTIONAL_SETTINGS: Final[tuple[OptionalSettings | str, ...]] = ()
 DEFAULT_PERIODIC_REFRESH_INTERVAL: Final = 15
 DEFAULT_PROGRAM_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
-DEFAULT_SESSION_RECORDER_START_FOR_SECONDS: Final = 120
+DEFAULT_SESSION_RECORDER_START_FOR_SECONDS: Final = 180
 DEFAULT_STORAGE_DIRECTORY: Final = "aiohomematic_storage"
 DEFAULT_SYSVAR_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
 DEFAULT_SYS_SCAN_INTERVAL: Final = 30

aiohomematic/store/persistent.py

@@ -43,6 +43,7 @@ import json
 import logging
 import os
 from typing import Any, Final, Self
+import zipfile
 
 import orjson
 from slugify import slugify
@@ -198,7 +199,13 @@ class BasePersistentFile(ABC):
         )
 
     async def load(self, *, file_path: str | None = None) -> DataOperationResult:
-        """Load data from disk into the dictionary."""
+        """
+        Load data from disk into the dictionary.
+
+        Supports plain JSON files and ZIP archives containing a JSON file.
+        When a ZIP archive is provided, the first JSON member inside the archive
+        will be loaded.
+        """
         if not file_path and not check_or_create_directory(directory=self._directory):
             return DataOperationResult.NO_LOAD
 
@@ -206,16 +213,25 @@ class BasePersistentFile(ABC):
             return DataOperationResult.NO_LOAD
 
         def _perform_load() -> DataOperationResult:
-            with open(file=file_path, encoding=UTF_8) as file_pointer:
-                try:
-                    data = json.loads(file_pointer.read(), object_hook=regular_to_default_dict_hook)
-                    if (converted_hash := hash_sha256(value=data)) == self.last_hash_saved:
-                        return DataOperationResult.NO_LOAD
-                    self._persistent_content.clear()
-                    self._persistent_content.update(data)
-                    self.last_hash_saved = converted_hash
-                except json.JSONDecodeError:
-                    return DataOperationResult.LOAD_FAIL
+            try:
+                if zipfile.is_zipfile(file_path):
+                    with zipfile.ZipFile(file_path, mode="r") as zf:
+                        # Prefer json files; pick the first .json entry if available
+                        if not (json_members := [n for n in zf.namelist() if n.lower().endswith(".json")]):
+                            return DataOperationResult.LOAD_FAIL
+                        raw = zf.read(json_members[0]).decode(UTF_8)
+                        data = json.loads(raw, object_hook=regular_to_default_dict_hook)
+                else:
+                    with open(file=file_path, encoding=UTF_8) as file_pointer:
+                        data = json.loads(file_pointer.read(), object_hook=regular_to_default_dict_hook)
+
+                if (converted_hash := hash_sha256(value=data)) == self.last_hash_saved:
+                    return DataOperationResult.NO_LOAD
+                self._persistent_content.clear()
+                self._persistent_content.update(data)
+                self.last_hash_saved = converted_hash
+            except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
+                return DataOperationResult.LOAD_FAIL
             return DataOperationResult.LOAD_SUCCESS
 
         async with self._save_load_semaphore:

aiohomematic/support.py

@@ -582,6 +582,15 @@ def create_random_device_addresses(*, addresses: list[str]) -> dict[str, str]:
     return {adr: f"VCU{int(random.randint(1000000, 9999999))}" for adr in addresses}
 
 
+def shrink_json_file(file_name: str) -> None:
+    """Shrink a json file."""
+    with open(file_name, "rb") as f:
+        data = orjson.loads(f.read())
+
+    with open(file_name, "wb") as f:
+        f.write(orjson.dumps(data))
+
+
 # --- Structured error boundary logging helpers ---
 
 _BOUNDARY_MSG = "error_boundary"

{aiohomematic-2025.10.10.dist-info → aiohomematic-2025.10.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.10
+Version: 2025.10.11
 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.10.dist-info → aiohomematic-2025.10.11.dist-info}/RECORD

@@ -1,6 +1,6 @@
 aiohomematic/__init__.py,sha256=Uo9CIoil0Arl3GwtgMZAwM8jhcgoBKcZEgj8cXYlswY,2258
 aiohomematic/async_support.py,sha256=01chvt-Ac_UIAWI39VeGpQV9AmxpSCbNyfPPAwX_Qqc,7865
-aiohomematic/const.py,sha256=fF-aNIwaVEwjG9QxsL-oRntUYi-DcnxH8aRrwYAJ560,27427
+aiohomematic/const.py,sha256=FeWi0VLHTN0nP61c4xZjt1TRJfn2azFchkYPHiXCPrQ,27427
 aiohomematic/context.py,sha256=hGE-iPcPt21dY-1MZar-Hyh9YaKL-VS42xjrulIVyRQ,429
 aiohomematic/converter.py,sha256=FiHU71M5RZ7N5FXJYh2CN14s63-PM-SHdb0cJ_CLx54,3602
 aiohomematic/decorators.py,sha256=cSW0aF3PzrW_qW6H0sjRNH9eqO8ysqhXZDgJ2OJTZM4,11038
@@ -8,14 +8,14 @@ aiohomematic/exceptions.py,sha256=RLldRD4XY8iYuNYVdspCbbphGcKsximB7R5OL7cYKw0,50
 aiohomematic/hmcli.py,sha256=_QZFKcfr_KJrdiyBRbhz0f8LZ95glD7LgJBmQc8cwog,4911
 aiohomematic/property_decorators.py,sha256=3Id1_rWIYnwyN_oSMgbh7XNKz9HPkGTC1CeS5ei04ZQ,17139
 aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic/support.py,sha256=R275ZIKoufMZORcBa7Tiq0MZ7KtMZiqoUXUJX4LM1qA,23083
+aiohomematic/support.py,sha256=eUbtdnrkq99o2DxJzyai5LHqrkpXC_gWQtrkI4zIgzg,23310
 aiohomematic/validator.py,sha256=qX5janicu4jLrAVzKoyWgXe1XU4EOjk5-QhNFL4awTQ,3541
 aiohomematic/central/__init__.py,sha256=xqlWOAKbnLzYTteVHIdxFpLCBcrTzgub8ZztJd43HTw,94122
 aiohomematic/central/decorators.py,sha256=vrujdw2QMXva-7DGXMQyittujx0q7cPuGD-SCeQlD30,6886
-aiohomematic/central/rpc_server.py,sha256=PX6idUEZ5j9fx9y__Q--Zcc2cyFMhLBie-lNvkx1bsI,10949
+aiohomematic/central/rpc_server.py,sha256=EhvBy8oMjBTR8MvH5QXo3lvlsCNJrvu6B85_CAg6sG8,10742
 aiohomematic/client/__init__.py,sha256=14lx62VvPm9yQgm5nUVdzgAKkhS8GXeAvV8gmGbldl8,73941
 aiohomematic/client/_rpc_errors.py,sha256=IaYjX60mpBJ43gDCJjuUSVraamy5jXHTRjOnutK4azs,2962
-aiohomematic/client/json_rpc.py,sha256=u25nedb3AEK54GN9F4z3oOCfoE-YTYZpL4166OsRPAg,51274
+aiohomematic/client/json_rpc.py,sha256=mrPvRR4hmc2MfMec8tjdQbF2RK1u0W1byOFUsiEP4fs,51319
 aiohomematic/client/rpc_proxy.py,sha256=T6tmfBAJJSFxzBLrhKJc6_KiHyTs5EVnStQsVJA5YkY,11604
 aiohomematic/model/__init__.py,sha256=gUYa8ROWSbXjZTWUTmINZ1bbYAxGkVpA-onxaJN2Iso,5436
 aiohomematic/model/data_point.py,sha256=VdwzjRrBDaYhWyIQL4JVC9wYTFMSwvwymYSEAPxjms8,41573
@@ -67,12 +67,10 @@ aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m
 aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
 aiohomematic/store/__init__.py,sha256=PHwF_tw_zL20ODwLywHgpOLWrghQo_BMZzeiQSXN1Fc,1081
 aiohomematic/store/dynamic.py,sha256=kgZs5gJ4i8bHZKkJ883xuLecSKdjj6UwlLRJAvQcNGI,22528
-aiohomematic/store/persistent.py,sha256=RVd8opnPmjM-iXhtZ79B5a6QDNsRUkbA0LF6UKTT2cw,39430
+aiohomematic/store/persistent.py,sha256=SBL8AhqUzpoPtJ50GkLYHwvRJS52fBWqNPjgvykxbY8,40233
 aiohomematic/store/visibility.py,sha256=0y93kPTugqQsrh6kKamfgwBkbIdBPEZpQVv_1NaLz3A,31662
-aiohomematic-2025.10.10.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=gpWkbyt_iCQCwxsvKahYl4knFrzyBku5WwbR83_mgM8,12825
-aiohomematic-2025.10.10.dist-info/METADATA,sha256=iobe6GKEwejmW7IGIY47Jwabivu15Kn1cLifFivDh7E,7604
-aiohomematic-2025.10.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.10.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
-aiohomematic-2025.10.10.dist-info/RECORD,,
+aiohomematic-2025.10.11.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic-2025.10.11.dist-info/METADATA,sha256=r7XE6UJklJaiC8x0NM-lKx3BSErN8oj2ajLnb2Y9mVY,7604
+aiohomematic-2025.10.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.11.dist-info/top_level.txt,sha256=iGUvt1N-E72vKRq7Anpp62HwkQngStrUK0JfL1zj1TE,13
+aiohomematic-2025.10.11.dist-info/RECORD,,

aiohomematic-2025.10.11.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiohomematic

aiohomematic-2025.10.10.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-aiohomematic
-aiohomematic_support

aiohomematic_support/__init__.py

@@ -1 +0,0 @@
-"""Module to support aiohomematic testing with a local client."""

aiohomematic_support/client_local.py

@@ -1,361 +0,0 @@
-"""The local client-object and its methods."""
-
-from __future__ import annotations
-
-from _collections import defaultdict
-from dataclasses import dataclass
-from datetime import datetime
-import importlib.resources
-import logging
-import os
-from typing import Any, Final, cast
-
-import orjson
-
-from aiohomematic.client import _LOGGER, Client, ClientConfig
-from aiohomematic.const import (
-    ADDRESS_SEPARATOR,
-    DP_KEY_VALUE,
-    UTF_8,
-    WAIT_FOR_CALLBACK,
-    CallSource,
-    CommandRxMode,
-    DescriptionMarker,
-    DeviceDescription,
-    Interface,
-    ParameterData,
-    ParamsetKey,
-    ProductGroup,
-    ProgramData,
-    ProxyInitState,
-    SystemInformation,
-    SystemVariableData,
-)
-from aiohomematic.decorators import inspector
-from aiohomematic.support import is_channel_address
-
-LOCAL_SERIAL: Final = "0815_4711"
-BACKEND_LOCAL: Final = "PyDevCCU"
-
-
-class ClientLocal(Client):  # pragma: no cover
-    """Local client object to provide access to locally stored files."""
-
-    def __init__(self, *, client_config: ClientConfig, local_resources: LocalRessources) -> None:
-        """Initialize the Client."""
-        super().__init__(client_config=client_config)
-        self._local_resources = local_resources
-        self._paramset_descriptions_cache: dict[str, dict[ParamsetKey, dict[str, ParameterData]]] = defaultdict(
-            lambda: defaultdict(dict)
-        )
-
-    async def init_client(self) -> None:
-        """Init the client."""
-        self._system_information = await self._get_system_information()
-
-    @property
-    def available(self) -> bool:
-        """Return the availability of the client."""
-        return True
-
-    @property
-    def model(self) -> str:
-        """Return the model of the backend."""
-        return BACKEND_LOCAL
-
-    def get_product_group(self, *, model: str) -> ProductGroup:
-        """Return the product group."""
-        l_model = model.lower()
-        if l_model.startswith("hmipw"):
-            return ProductGroup.HMIPW
-        if l_model.startswith("hmip"):
-            return ProductGroup.HMIP
-        if l_model.startswith("hmw"):
-            return ProductGroup.HMW
-        if l_model.startswith("hm"):
-            return ProductGroup.HM
-        return ProductGroup.UNKNOWN
-
-    @property
-    def supports_ping_pong(self) -> bool:
-        """Return the supports_ping_pong info of the backend."""
-        return True
-
-    @property
-    def supports_push_updates(self) -> bool:
-        """Return the client supports push update."""
-        return True
-
-    async def initialize_proxy(self) -> ProxyInitState:
-        """Init the proxy has to tell the backend where to send the events."""
-        return ProxyInitState.INIT_SUCCESS
-
-    async def deinitialize_proxy(self) -> ProxyInitState:
-        """De-init to stop the backend from sending events for this remote."""
-        return ProxyInitState.DE_INIT_SUCCESS
-
-    async def stop(self) -> None:
-        """Stop depending services."""
-
-    @inspector(re_raise=False, measure_performance=True)
-    async def fetch_all_device_data(self) -> None:
-        """Fetch all device data from the backend."""
-
-    @inspector(re_raise=False, measure_performance=True)
-    async def fetch_device_details(self) -> None:
-        """Fetch names from the backend."""
-
-    @inspector(re_raise=False, no_raise_return=False)
-    async def is_connected(self) -> bool:
-        """
-        Perform actions required for connectivity check.
-
-        Connection is not connected, if three consecutive checks fail.
-        Return connectivity state.
-        """
-        return True
-
-    def is_callback_alive(self) -> bool:
-        """Return if XmlRPC-Server is alive based on received events for this client."""
-        return True
-
-    @inspector(re_raise=False, no_raise_return=False)
-    async def check_connection_availability(self, *, handle_ping_pong: bool) -> bool:
-        """Send ping to the backend to generate PONG event."""
-        if handle_ping_pong and self.supports_ping_pong:
-            self._ping_pong_cache.handle_send_ping(ping_ts=datetime.now())
-        return True
-
-    @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."""
-        return True
-
-    @inspector
-    async def delete_system_variable(self, *, name: str) -> bool:
-        """Delete a system variable from the backend."""
-        return True
-
-    @inspector
-    async def get_system_variable(self, *, name: str) -> str:
-        """Get single system variable from the backend."""
-        return "Empty"
-
-    @inspector(re_raise=False)
-    async def get_all_system_variables(
-        self, *, markers: tuple[DescriptionMarker | str, ...]
-    ) -> tuple[SystemVariableData, ...]:
-        """Get all system variables from the backend."""
-        return ()
-
-    @inspector(re_raise=False)
-    async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...]:
-        """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, if available."""
-        return {}
-
-    @inspector(re_raise=False, no_raise_return={})
-    async def get_all_functions(self) -> dict[str, set[str]]:
-        """Get all functions, if available."""
-        return {}
-
-    async def _get_system_information(self) -> SystemInformation:
-        """Get system information of the backend."""
-        return SystemInformation(available_interfaces=(Interface.BIDCOS_RF,), serial=LOCAL_SERIAL)
-
-    @inspector(re_raise=False, measure_performance=True)
-    async def list_devices(self) -> tuple[DeviceDescription, ...] | None:
-        """Get device descriptions from the backend."""
-        if not self._local_resources:
-            _LOGGER.warning(
-                "LIST_DEVICES: missing local_resources in config for %s",
-                self.central.name,
-            )
-            return None
-        device_descriptions: list[DeviceDescription] = []
-        if local_device_descriptions := cast(
-            list[Any],
-            await self._load_all_json_files(
-                anchor=self._local_resources.anchor,
-                resource=self._local_resources.device_description_dir,
-                include_list=list(self._local_resources.address_device_translation.values()),
-                exclude_list=self._local_resources.ignore_devices_on_create,
-            ),
-        ):
-            for device_description in local_device_descriptions:
-                device_descriptions.extend(device_description)
-        return tuple(device_descriptions)
-
-    @inspector(log_level=logging.NOTSET)
-    async def get_value(
-        self,
-        *,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        parameter: str,
-        call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
-    ) -> Any:
-        """Return a value from the backend."""
-        return
-
-    @inspector(re_raise=False, no_raise_return=set())
-    async def set_value(
-        self,
-        *,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        parameter: str,
-        value: Any,
-        wait_for_callback: int | None = WAIT_FOR_CALLBACK,
-        rx_mode: CommandRxMode | None = None,
-        check_against_pd: bool = False,
-    ) -> set[DP_KEY_VALUE]:
-        """Set single value on paramset VALUES."""
-        # store the send value in the last_value_send_cache
-        result = self._last_value_send_cache.add_set_value(
-            channel_address=channel_address, parameter=parameter, value=value
-        )
-        # fire an event to fake the state change for a simple parameter
-        await self.central.data_point_event(
-            interface_id=self.interface_id, channel_address=channel_address, parameter=parameter, value=value
-        )
-        return result
-
-    @inspector
-    async def get_paramset(
-        self,
-        *,
-        address: str,
-        paramset_key: ParamsetKey | str,
-        call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
-    ) -> Any:
-        """
-        Return a paramset from the backend.
-
-        Address is usually the channel_address,
-        but for bidcos devices there is a master paramset at the device.
-        """
-        return {}
-
-    async def _get_paramset_description(
-        self, *, address: str, paramset_key: ParamsetKey
-    ) -> dict[str, ParameterData] | None:
-        """Get paramset description from the backend."""
-        if not self._local_resources:
-            _LOGGER.warning(
-                "GET_PARAMSET_DESCRIPTION: missing local_resources in config for %s",
-                self.central.name,
-            )
-            return None
-
-        if (
-            address not in self._paramset_descriptions_cache
-            and (file_name := self._local_resources.address_device_translation.get(address.split(ADDRESS_SEPARATOR)[0]))
-            and (
-                data := await self._load_json_file(
-                    anchor=self._local_resources.anchor,
-                    resource=self._local_resources.paramset_description_dir,
-                    file_name=file_name,
-                )
-            )
-        ):
-            self._paramset_descriptions_cache.update(data)
-
-        return self._paramset_descriptions_cache[address].get(paramset_key)
-
-    @inspector(measure_performance=True)
-    async def put_paramset(
-        self,
-        *,
-        channel_address: str,
-        paramset_key_or_link_address: ParamsetKey | str,
-        values: Any,
-        wait_for_callback: int | None = WAIT_FOR_CALLBACK,
-        rx_mode: CommandRxMode | None = None,
-        check_against_pd: bool = False,
-    ) -> set[DP_KEY_VALUE]:
-        """
-        Set paramsets manually.
-
-        Address is usually the channel_address,
-        but for bidcos devices there is a master paramset at the device.
-        """
-        # store the send value in the last_value_send_cache
-        if isinstance(paramset_key_or_link_address, str) and is_channel_address(address=paramset_key_or_link_address):
-            result = set()
-        else:
-            result = self._last_value_send_cache.add_put_paramset(
-                channel_address=channel_address,
-                paramset_key=ParamsetKey(paramset_key_or_link_address),
-                values=values,
-            )
-
-        # fire an event to fake the state change for the content of a paramset
-        for parameter in values:
-            await self.central.data_point_event(
-                interface_id=self.interface_id,
-                channel_address=channel_address,
-                parameter=parameter,
-                value=values[parameter],
-            )
-        return result
-
-    async def _load_all_json_files(
-        self,
-        *,
-        anchor: str,
-        resource: str,
-        include_list: list[str] | None = None,
-        exclude_list: list[str] | None = None,
-    ) -> list[Any] | None:
-        """Load all json files from disk into dict."""
-        if not include_list:
-            return []
-        if not exclude_list:
-            exclude_list = []
-        result: list[Any] = []
-        resource_path = os.path.join(str(importlib.resources.files(anchor)), resource)
-        for file_name in os.listdir(resource_path):
-            if file_name not in include_list or file_name in exclude_list:
-                continue
-            if file_content := await self._load_json_file(anchor=anchor, resource=resource, file_name=file_name):
-                result.append(file_content)
-        return result
-
-    async def _load_json_file(self, *, anchor: str, resource: str, file_name: str) -> Any | None:
-        """Load json file from disk into dict."""
-        package_path = str(importlib.resources.files(anchor))
-
-        def _perform_load() -> Any | None:
-            with open(
-                file=os.path.join(package_path, resource, file_name),
-                encoding=UTF_8,
-            ) as fptr:
-                return orjson.loads(fptr.read())
-
-        return await self.central.looper.async_add_executor_job(_perform_load, name="load-json-file")
-
-
-@dataclass(frozen=True, kw_only=True, slots=True)
-class LocalRessources:
-    """Dataclass with information for local client."""
-
-    address_device_translation: dict[str, str]
-    ignore_devices_on_create: list[str]
-    anchor: str = "pydevccu"
-    device_description_dir: str = "device_descriptions"
-    paramset_description_dir: str = "paramset_descriptions"