aiohomematic 2025.10.10__tar.gz → 2025.10.11__tar.gz

aiohomematic-2025.10.11/MANIFEST.in

@@ -0,0 +1,14 @@
+# MANIFEST.in
+
+# Include the main package and important files
+graft aiohomematic
+include README.md
+include LICENSE
+
+# Exclude tests and build artifacts
+prune tests
+prune build
+prune dist
+
+# IMPORTANT: exclude support package from the sdist tarball
+prune aiohomematic_support

{aiohomematic-2025.10.10 → aiohomematic-2025.10.11}/PKG-INFO

@@ -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 → aiohomematic-2025.10.11}/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-2025.10.10 → aiohomematic-2025.10.11}/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-2025.10.10 → aiohomematic-2025.10.11}/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-2025.10.10 → aiohomematic-2025.10.11}/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-2025.10.10 → aiohomematic-2025.10.11}/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 → aiohomematic-2025.10.11}/aiohomematic.egg-info/PKG-INFO

@@ -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 → aiohomematic-2025.10.11}/aiohomematic.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 setup.cfg
@@ -77,37 +78,4 @@ aiohomematic/rega_scripts/set_system_variable.fn
 aiohomematic/store/__init__.py
 aiohomematic/store/dynamic.py
 aiohomematic/store/persistent.py
-aiohomematic/store/visibility.py
-aiohomematic_support/__init__.py
-aiohomematic_support/client_local.py
-tests/test_action.py
-tests/test_async_support.py
-tests/test_binary_sensor.py
-tests/test_button.py
-tests/test_calculated_support.py
-tests/test_central.py
-tests/test_central_pydevccu.py
-tests/test_climate.py
-tests/test_cover.py
-tests/test_decorator.py
-tests/test_device.py
-tests/test_dynamic_caches.py
-tests/test_entity.py
-tests/test_event.py
-tests/test_json_rpc.py
-tests/test_json_rpc_client_integration.py
-tests/test_kwonly_lint.py
-tests/test_light.py
-tests/test_lock.py
-tests/test_logging_support.py
-tests/test_number.py
-tests/test_select.py
-tests/test_sensor.py
-tests/test_session_recorder.py
-tests/test_siren.py
-tests/test_support.py
-tests/test_support_extra.py
-tests/test_switch.py
-tests/test_text.py
-tests/test_valve.py
-tests/test_xml_rpc_proxy_integration.py
+aiohomematic/store/visibility.py

aiohomematic-2025.10.11/aiohomematic.egg-info/top_level.txt

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

{aiohomematic-2025.10.10 → aiohomematic-2025.10.11}/pyproject.toml

@@ -46,8 +46,8 @@ include-package-data = true
 version = {attr = "aiohomematic.const.VERSION"}
 
 [tool.setuptools.packages.find]
-include = ["aiohomematic*"]
-exclude = ["tests", "tests.*", "dist", "build"]
+include = ["aiohomematic", "aiohomematic.*"]
+exclude = ["aiohomematic_support", "aiohomematic_support.*", "tests", "tests.*", "dist", "build"]
 
 [tool.setuptools.package-data]
 aiohomematic = ["py.typed", "rega_scripts/*.fn"]
@@ -571,7 +571,6 @@ branch = true
 source = ["aiohomematic",]
 omit = [
   "aiohomematic/hmcli.py",
-  "aiohomematic/client/__init__.py",
   "aiohomematic/validator.py",
   "aiohomematic/exceptions.py",
   "aiohomematic/central/rpc_server.py",

aiohomematic-2025.10.10/aiohomematic.egg-info/top_level.txt

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

aiohomematic-2025.10.10/aiohomematic_support/__init__.py

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

aiohomematic-2025.10.10/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"