aiohomematic 2025.8.6__py3-none-any.whl

aiohomematic-2025.8.6.dist-info/RECORD

@@ -0,0 +1,77 @@
+aiohomematic/__init__.py,sha256=VoLXfPmEFWVOFseEusar-BcfKhQ8pBthrA7M6_QkWg8,1741
+aiohomematic/async_support.py,sha256=8KzftPu9CHRpxxXU8ElExYYadN9P6rSkMvLK5Ci2Xlo,5476
+aiohomematic/const.py,sha256=qT1lXjFm1WIemDsV5owjuml2GqOcFVSUrbwGHCFC8gE,23474
+aiohomematic/context.py,sha256=4CNoLd4PQ8MsLED_3D-Gcxo4h2UNlyQNd7QUE_0uvBA,253
+aiohomematic/converter.py,sha256=eZ3iQPCfYZwqxQgUy4q6aMne_Bay-27f1HQuMRdabZ4,2922
+aiohomematic/decorators.py,sha256=YD7zX9jBN-F-NdfKGNn0STqR6cndpoBCMuXaBvgvam4,7088
+aiohomematic/exceptions.py,sha256=uMmbR-rWmCnseqmOPSHZ826YZ10uJrxG1c0w7VCYPZ0,4579
+aiohomematic/hmcli.py,sha256=9oeXjCy50hkjMj7t1c9Cw0bz-LnXzjheKQBQDyGQQRk,4582
+aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiohomematic/support.py,sha256=PgtFBHLVllnXS8AweQCNBiekL1__EgEAcGPjPNrqUi8,15741
+aiohomematic/validator.py,sha256=Xxcmf2MzjIvzsDAfJsPR-cSN8S06sub-V3TCn6ronAs,1765
+aiohomematic/caches/__init__.py,sha256=Uco9Y5fVmIPm_iRoLPWJnJNYfs9PY6VL-Jmj_3cT3yE,391
+aiohomematic/caches/dynamic.py,sha256=CREQR87-I8rvvFOyrxaL9q161VKqEvyaRYi55fc-zos,21755
+aiohomematic/caches/persistent.py,sha256=pKWvzOoIB55iFtCD9RoufrxOPsorZU2QH5IcXlRujRY,19586
+aiohomematic/caches/visibility.py,sha256=mEOLz3WMzDtBp6ghh9Y0Gg_DUJBSH1SyqyCivFgY5wM,29843
+aiohomematic/central/__init__.py,sha256=DaEtE_0ODH5GO_HBJt1OzZ2fIDG8r1UhE8odPTTZo0k,84226
+aiohomematic/central/decorators.py,sha256=Lgc9SzvugZ45h_1anPjBNgzTjQ8BgDHnquE1PD48-XY,4899
+aiohomematic/central/xml_rpc_server.py,sha256=xwcb57ow7YEUS4By0HSBwzRSEY8kC9nZ-7hl4M-EWqI,9957
+aiohomematic/client/__init__.py,sha256=n2rNU3L1Xr453xsTCTM2mh5N1alp0yftAIienziB6ak,69753
+aiohomematic/client/json_rpc.py,sha256=HGgCXcp1uCfDkBdHlMNV8OD5O2PfWFRYNmiX5Pv1FO8,46463
+aiohomematic/client/xml_rpc.py,sha256=pUFdJZBtirNyNNyHbeMDOEh2mFkxQf_zrvjd56n1Lv4,8161
+aiohomematic/model/__init__.py,sha256=AbrppmY8X5rJkBV3c7Ggndk16Qvl-1S0uUWJqqxmXUE,5380
+aiohomematic/model/data_point.py,sha256=mMiUzGmZ_261iYV0FSCTCLGal7WTh69UqdMd_IfV0sg,39739
+aiohomematic/model/decorators.py,sha256=sIxYsoyIE9aqbbrAnuFSvebLhNZC_DaMlEOBe6T_fRA,6718
+aiohomematic/model/device.py,sha256=w6zWUFSI7yXbRyrFwfQxWzzk7kortIy8JhJGf7IG1fo,52435
+aiohomematic/model/event.py,sha256=4dVuW3IBXkXcYhJUBtV8ax8dq4krtomA0wxbvXPuNCc,6935
+aiohomematic/model/support.py,sha256=fXaGvD6ywaOmDihIAHjn-z3AuIn0Q3Wiq7EqcxUV6uc,19630
+aiohomematic/model/update.py,sha256=r7Swejskx2Gg0F3zKaiZv5dBIuG49ZhvE3GlDG4PHB4,4880
+aiohomematic/model/calculated/__init__.py,sha256=hzVYpyyXWUIf0skSLTrOhaczVg6mCDpPg1KJsRGWukE,2734
+aiohomematic/model/calculated/climate.py,sha256=yu3mFBAO6Cb_r68v197uXseOl9P1jz7Dz0tUaCY-6FE,8436
+aiohomematic/model/calculated/data_point.py,sha256=-ZC10Iz5opXqs2nkiwerF3caMIMdWwS9fVwYYaagTE0,11268
+aiohomematic/model/calculated/operating_voltage_level.py,sha256=F09jW2rFtjxrsR25xkN-uZxJAdw_dcDr8hv-xvTiBCs,13932
+aiohomematic/model/calculated/support.py,sha256=ht_KSFUT2Dze9wjw_o0Gp2-PGo4on0W0CZujhCWzwIk,6019
+aiohomematic/model/custom/__init__.py,sha256=6-jN7l6DPIUSCANw15SwNQFyL8aXxn8Me8m8fNHkWKc,5987
+aiohomematic/model/custom/climate.py,sha256=Sd3KofB1G085bKK1JKB7k4uaySD3W4SKbw-Fg9FH0PU,53930
+aiohomematic/model/custom/const.py,sha256=ifJgooQqo43qEqfPQTIcyY7IcUeFvM0-y4WvP-_HgXM,4882
+aiohomematic/model/custom/cover.py,sha256=aU8sSdKnGuiPBAO73GtmOMcYLoU7VmFldBxDf601dII,27474
+aiohomematic/model/custom/data_point.py,sha256=jpDpQlZs2iYeI4dms1kkhzAMa__f9Dacvf93E6ad5xs,13843
+aiohomematic/model/custom/definition.py,sha256=VQ8dROZSAVu-CarYc2jN_KrlvGI1kjhwUqD0ZR1qTUA,35402
+aiohomematic/model/custom/light.py,sha256=IGT98GlqRftNzZpFP8NR_aQG_EQHyr191O5xkcpVaz4,43843
+aiohomematic/model/custom/lock.py,sha256=6_xOeUFfVRJh_BjTY6RVLaCVmIozQo-uUMrbDqASt8g,11858
+aiohomematic/model/custom/siren.py,sha256=5WLiYfUE7vBNVDlV8Whjqh-7PVMiReW-CI5MDH25R0s,9573
+aiohomematic/model/custom/support.py,sha256=Rn6ikcSE2Hcqv34k2h02osXW45poS0hO3GX_wtTpMyE,1374
+aiohomematic/model/custom/switch.py,sha256=XIhlGvtkZaId4jNE1XtYpJfFuvFofzlAN6tUPHzLgTA,6790
+aiohomematic/model/custom/valve.py,sha256=u1mv5-hllX89GVN5Ir_svJcJOGdcS8JNYu0NAZsthTc,4147
+aiohomematic/model/generic/__init__.py,sha256=qYNbPuFlanpDsrw9GKbWAT48pcNaAYWKgERpkv91HzU,7534
+aiohomematic/model/generic/action.py,sha256=NMbMbNX6JSQH56M4CkkYstx1nb1nYuLXtFjZR2wg2UU,915
+aiohomematic/model/generic/binary_sensor.py,sha256=jHyvrkHyFuWdVOQiBWmD25HZqwk6tU6VKuWiZyrt2kU,805
+aiohomematic/model/generic/button.py,sha256=-6W7dEGq4bXvdEtQTtSA-54PurHD6in8umBaUiUtqNA,663
+aiohomematic/model/generic/data_point.py,sha256=QTzbjXSmOmDKrr7nFl1YrRk14gN07Iv7FbFp58Ih69I,5861
+aiohomematic/model/generic/number.py,sha256=6JIFPNED5WjghT1o0hM-OObhUXX42t-Cv7jAhNy52rw,2522
+aiohomematic/model/generic/select.py,sha256=-DUuavyD7-CicNZboA_kAV4kBN6w7mtoP_5Sn_6fNgA,1388
+aiohomematic/model/generic/sensor.py,sha256=dMjI0RSKIl6xI1VnTPFJe5HCUdfOKtfAXHLtX0Hwoiw,2171
+aiohomematic/model/generic/switch.py,sha256=bzJKvLmGN7yBoWSTZCjiXRnq2sBduKvRVGohBGrjKSE,1757
+aiohomematic/model/generic/text.py,sha256=ig-ilSa6CFlf65Sopg-E5jC9rK0Ma1vs2nzBxdprIpQ,772
+aiohomematic/model/hub/__init__.py,sha256=3LTVY_pPKdJsHBDx8BFzV0nQwDM9zDU-7JqSlsPU_Wg,13492
+aiohomematic/model/hub/binary_sensor.py,sha256=MG75YRZAkLOCs8ZVj2kr-EFgUte4v6dV_C3vdqZ-4jU,670
+aiohomematic/model/hub/button.py,sha256=3NWWQDjsQ4aIi3WGOVTWNi8Ry2shsvmqdgLNF6SvOGg,810
+aiohomematic/model/hub/data_point.py,sha256=44AXesJ6X9YGpNPDyDwHf6Z0VjB3thdgm040gILxxUc,10427
+aiohomematic/model/hub/number.py,sha256=auwUxR2J5rF_ZKSKSDo4XSiZUcXJ0uYUiCJO94_vmQM,1145
+aiohomematic/model/hub/select.py,sha256=UTng9oNf7y-x-2wMnd7UL8rZ0goyH8GsfQhz8MJrw8o,1579
+aiohomematic/model/hub/sensor.py,sha256=q_QWbkt2rycHeJJ5hlBGJJg0-Rfum8vrLA8BoZZyGq4,1110
+aiohomematic/model/hub/switch.py,sha256=W5iGOgL4A8BWFw5_rEYcfxyRVCnXIYy5tYt5sbpShCg,1312
+aiohomematic/model/hub/text.py,sha256=LGgFQNHgXreCIzMe3j21KFiOjliLv5a0xJrnUb1_P9k,908
+aiohomematic/rega_scripts/fetch_all_device_data.fn,sha256=GX9GDjWCfMgEPN6uP9RHD75IppcMth5NmRqVsQWUYJ4,3168
+aiohomematic/rega_scripts/get_program_descriptions.fn,sha256=pGmj377MkqbZi6j-UBKQAsXTphwh1kDwDKqXij8zUBE,835
+aiohomematic/rega_scripts/get_serial.fn,sha256=t1oeo-sB_EuVeiY24PLcxFSkdQVgEWGXzpemJQZFybY,1079
+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.8.6.dist-info/licenses/LICENSE,sha256=4kjAuxWtZ7ln4Gj-i8ZxrHEyPijP_bfevH5wjQxntnU,1069
+aiohomematic_support/__init__.py,sha256=_0YtF4lTdC_k6-zrM2IefI0u0LMr_WA61gXAyeGLgbY,66
+aiohomematic_support/client_local.py,sha256=cvkO3tcxSJKy5ZLVdeqDbvSmeottxqZJNI4ccdxIVD4,12524
+aiohomematic-2025.8.6.dist-info/METADATA,sha256=Tzr48xIbtwyYn6YAreZC9k9Ri9x4F0ErG0erow_58zI,3244
+aiohomematic-2025.8.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.8.6.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
+aiohomematic-2025.8.6.dist-info/RECORD,,

aiohomematic-2025.8.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aiohomematic-2025.8.6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Daniel Perna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiohomematic-2025.8.6.dist-info/top_level.txt

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

aiohomematic_support/__init__.py

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

aiohomematic_support/client_local.py

@@ -0,0 +1,349 @@
+"""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 = "Local CCU"
+
+
+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 CCU / Homegear where to send the events."""
+        return ProxyInitState.INIT_SUCCESS
+
+    async def deinitialize_proxy(self) -> ProxyInitState:
+        """De-init to stop CCU 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 CCU."""
+
+    @inspector(re_raise=False, measure_performance=True)
+    async def fetch_device_details(self) -> None:
+        """Fetch names from 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 CCU 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 CCU / Homegear."""
+        return True
+
+    @inspector()
+    async def set_program_state(self, pid: str, state: bool) -> bool:
+        """Set the program state on CCU / Homegear."""
+        return True
+
+    @inspector(measure_performance=True)
+    async def set_system_variable(self, legacy_name: str, value: Any) -> bool:
+        """Set a system variable on CCU / Homegear."""
+        return True
+
+    @inspector()
+    async def delete_system_variable(self, name: str) -> bool:
+        """Delete a system variable from CCU / Homegear."""
+        return True
+
+    @inspector()
+    async def get_system_variable(self, name: str) -> str:
+        """Get single system variable from CCU / Homegear."""
+        return "Empty"
+
+    @inspector(re_raise=False)
+    async def get_all_system_variables(
+        self, markers: tuple[DescriptionMarker | str, ...]
+    ) -> tuple[SystemVariableData, ...]:
+        """Get all system variables from CCU / Homegear."""
+        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 CCU / Homegear."""
+        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 CCU."""
+        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(self.interface_id, channel_address, parameter, 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 CCU.
+
+        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 CCU."""
+        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,
+                    filename=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(self.interface_id, channel_address, parameter, 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 filename in os.listdir(resource_path):
+            if filename not in include_list or filename in exclude_list:
+                continue
+            if file_content := await self._load_json_file(anchor=anchor, resource=resource, filename=filename):
+                result.append(file_content)
+        return result
+
+    async def _load_json_file(self, anchor: str, resource: str, filename: 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, filename),
+                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"