aiohomematic-test-support 2025.10.16__tar.gz → 2025.10.17__tar.gz

{aiohomematic_test_support-2025.10.16/aiohomematic_test_support.egg-info → aiohomematic_test_support-2025.10.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.10.16
+Version: 2025.10.17
 Summary: Support-only package for AioHomematic (tests/dev). Not part of production builds.
 Author-email: SukramJ <sukramj@icloud.com>
 Project-URL: Homepage, https://github.com/SukramJ/aiohomematic

{aiohomematic_test_support-2025.10.16 → aiohomematic_test_support-2025.10.17}/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "2025.10.16"
+__version__ = "2025.10.17"
 """Module to support aiohomematic testing with a local client."""

{aiohomematic_test_support-2025.10.16 → aiohomematic_test_support-2025.10.17/aiohomematic_test_support.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.10.16
+Version: 2025.10.17
 Summary: Support-only package for AioHomematic (tests/dev). Not part of production builds.
 Author-email: SukramJ <sukramj@icloud.com>
 Project-URL: Homepage, https://github.com/SukramJ/aiohomematic

{aiohomematic_test_support-2025.10.16 → aiohomematic_test_support-2025.10.17}/aiohomematic_test_support.egg-info/SOURCES.txt

@@ -1,16 +1,18 @@
 MANIFEST.in
 README.md
 __init__.py
-client_local.py
 const.py
+factory.py
+helper.py
+mock.py
 py.typed
 pyproject.toml
-support.py
 ./__init__.py
-./client_local.py
 ./const.py
+./factory.py
+./helper.py
+./mock.py
 ./py.typed
-./support.py
 ./data/full_session_randomized_ccu.zip
 ./data/full_session_randomized_pydevccu.zip
 aiohomematic_test_support.egg-info/PKG-INFO

aiohomematic_test_support-2025.10.17/factory.py

@@ -0,0 +1,218 @@
+"""Helpers for tests."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+import contextlib
+import logging
+from typing import Any, Self, cast
+from unittest.mock import MagicMock, Mock, patch
+
+from aiohttp import ClientSession
+
+from aiohomematic.central import CentralConfig, CentralUnit
+from aiohomematic.client import Client, ClientConfig, InterfaceConfig
+from aiohomematic.const import LOCAL_HOST, BackendSystemEvent, Interface
+from aiohomematic_test_support import const
+from aiohomematic_test_support.mock import SessionPlayer, get_client_session, get_mock, get_xml_rpc_proxy
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=protected-access
+class FactoryWithClient:
+    """Factory for a central with one local client."""
+
+    def __init__(
+        self,
+        *,
+        player: SessionPlayer,
+        address_device_translation: set[str] | None = None,
+        do_mock_client: bool = True,
+        exclude_methods_from_mocks: set[str] | None = None,
+        ignore_custom_device_definition_models: list[str] | None = None,
+        ignore_devices_on_create: list[str] | None = None,
+        include_properties_in_mocks: set[str] | None = None,
+        interface_configs: set[InterfaceConfig] | None = None,
+        un_ignore_list: list[str] | None = None,
+    ) -> None:
+        """Init the central factory."""
+        self._player = player
+        self.init(
+            address_device_translation=address_device_translation,
+            do_mock_client=do_mock_client,
+            exclude_methods_from_mocks=exclude_methods_from_mocks,
+            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
+            ignore_devices_on_create=ignore_devices_on_create,
+            include_properties_in_mocks=include_properties_in_mocks,
+            interface_configs=interface_configs,
+            un_ignore_list=un_ignore_list,
+        )
+        self.system_event_mock = MagicMock()
+        self.ha_event_mock = MagicMock()
+
+    def init(
+        self,
+        *,
+        address_device_translation: set[str] | None = None,
+        do_mock_client: bool = True,
+        exclude_methods_from_mocks: set[str] | None = None,
+        ignore_custom_device_definition_models: list[str] | None = None,
+        ignore_devices_on_create: list[str] | None = None,
+        include_properties_in_mocks: set[str] | None = None,
+        interface_configs: set[InterfaceConfig] | None = None,
+        un_ignore_list: list[str] | None = None,
+    ) -> Self:
+        """Init the central factory."""
+        self._address_device_translation = address_device_translation
+        self._do_mock_client = do_mock_client
+        self._exclude_methods_from_mocks = exclude_methods_from_mocks
+        self._ignore_custom_device_definition_models = ignore_custom_device_definition_models
+        self._ignore_devices_on_create = ignore_devices_on_create
+        self._include_properties_in_mocks = include_properties_in_mocks
+        self._interface_configs = (
+            interface_configs
+            if interface_configs is not None
+            else {
+                InterfaceConfig(
+                    central_name=const.CENTRAL_NAME,
+                    interface=Interface.BIDCOS_RF,
+                    port=2001,
+                )
+            }
+        )
+        self._un_ignore_list = frozenset(un_ignore_list or [])
+        self._client_session = get_client_session(
+            player=self._player,
+            address_device_translation=self._address_device_translation,
+            ignore_devices_on_create=self._ignore_devices_on_create,
+        )
+        self._xml_proxy = get_xml_rpc_proxy(
+            player=self._player,
+            address_device_translation=self._address_device_translation,
+            ignore_devices_on_create=self._ignore_devices_on_create,
+        )
+        return self
+
+    async def get_raw_central(self) -> CentralUnit:
+        """Return a central based on give address_device_translation."""
+        interface_configs = self._interface_configs if self._interface_configs else set()
+        central = CentralConfig(
+            name=const.CENTRAL_NAME,
+            host=const.CCU_HOST,
+            username=const.CCU_USERNAME,
+            password=const.CCU_PASSWORD,
+            central_id="test1234",
+            interface_configs=interface_configs,
+            client_session=self._client_session,
+            un_ignore_list=self._un_ignore_list,
+            ignore_custom_device_definition_models=frozenset(self._ignore_custom_device_definition_models or []),
+            start_direct=True,
+        ).create_central()
+
+        central.register_backend_system_callback(cb=self.system_event_mock)
+        central.register_homematic_callback(cb=self.ha_event_mock)
+
+        assert central
+        self._client_session.set_central(central=central)  # type: ignore[attr-defined]
+        self._xml_proxy.set_central(central=central)
+        return central
+
+    async def get_default_central(self, *, start: bool = True) -> CentralUnit:
+        """Return a central based on give address_device_translation."""
+        central = await self.get_raw_central()
+
+        await self._xml_proxy.do_init()
+        patch("aiohomematic.client.ClientConfig._create_xml_rpc_proxy", return_value=self._xml_proxy).start()
+        patch("aiohomematic.central.CentralUnit._identify_ip_addr", return_value=LOCAL_HOST).start()
+
+        # Optionally patch client creation to return a mocked client
+        if self._do_mock_client:
+            _orig_create_client = ClientConfig.create_client
+
+            async def _mocked_create_client(config: ClientConfig) -> Client | Mock:
+                real_client = await _orig_create_client(config)
+                return cast(
+                    Mock,
+                    get_mock(
+                        instance=real_client,
+                        exclude_methods=self._exclude_methods_from_mocks,
+                        include_properties=self._include_properties_in_mocks,
+                    ),
+                )
+
+            patch("aiohomematic.client.ClientConfig.create_client", _mocked_create_client).start()
+
+        if start:
+            await central.start()
+            await central._init_hub()
+        assert central
+        return central
+
+
+async def get_central_client_factory(
+    player: SessionPlayer,
+    address_device_translation: set[str],
+    do_mock_client: bool,
+    ignore_devices_on_create: list[str] | None,
+    ignore_custom_device_definition_models: list[str] | None,
+    un_ignore_list: list[str] | None,
+) -> AsyncGenerator[tuple[CentralUnit, Client | Mock, FactoryWithClient]]:
+    """Return central factory."""
+    factory = FactoryWithClient(
+        player=player,
+        address_device_translation=address_device_translation,
+        do_mock_client=do_mock_client,
+        ignore_custom_device_definition_models=ignore_custom_device_definition_models,
+        ignore_devices_on_create=ignore_devices_on_create,
+        un_ignore_list=un_ignore_list,
+    )
+    central = await factory.get_default_central()
+    client = central.primary_client
+    assert client
+    try:
+        yield central, client, factory
+    finally:
+        await central.stop()
+        await central.clear_files()
+
+
+async def get_pydev_ccu_central_unit_full(
+    port: int,
+    client_session: ClientSession | None = None,
+) -> CentralUnit:
+    """Create and yield central, after all devices have been created."""
+    device_event = asyncio.Event()
+
+    def systemcallback(system_event: Any, *args: Any, **kwargs: Any) -> None:
+        if system_event == BackendSystemEvent.DEVICES_CREATED:
+            device_event.set()
+
+    interface_configs = {
+        InterfaceConfig(
+            central_name=const.CENTRAL_NAME,
+            interface=Interface.BIDCOS_RF,
+            port=port,
+        )
+    }
+
+    central = CentralConfig(
+        name=const.CENTRAL_NAME,
+        host=const.CCU_HOST,
+        username=const.CCU_USERNAME,
+        password=const.CCU_PASSWORD,
+        central_id="test1234",
+        interface_configs=interface_configs,
+        client_session=client_session,
+        program_markers=(),
+        sysvar_markers=(),
+    ).create_central()
+    central.register_backend_system_callback(cb=systemcallback)
+    await central.start()
+
+    # Wait up to 60 seconds for the DEVICES_CREATED event which signals that all devices are available
+    with contextlib.suppress(TimeoutError):
+        await asyncio.wait_for(device_event.wait(), timeout=60)
+
+    return central

aiohomematic_test_support-2025.10.17/helper.py

@@ -0,0 +1,45 @@
+"""Helpers for tests."""
+
+from __future__ import annotations
+
+import importlib.resources
+import logging
+import os
+from typing import Any
+
+import orjson
+
+from aiohomematic.central import CentralUnit
+from aiohomematic.const import UTF_8
+from aiohomematic.model.custom import CustomDataPoint
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=protected-access
+
+
+def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
+    """Load json file from disk into dict."""
+    package_path = str(importlib.resources.files(anchor))
+    with open(
+        file=os.path.join(package_path, resource, file_name),
+        encoding=UTF_8,
+    ) as fptr:
+        return orjson.loads(fptr.read())
+
+
+def get_prepared_custom_data_point(central: CentralUnit, address: str, channel_no: int) -> CustomDataPoint | None:
+    """Return the hm custom_data_point."""
+    if cdp := central.get_custom_data_point(address=address, channel_no=channel_no):
+        for dp in cdp._data_points.values():
+            dp._state_uncertain = False
+        return cdp
+    return None
+
+
+def load_device_description(file_name: str) -> Any:
+    """Load device description."""
+    dev_desc = _load_json_file(anchor="pydevccu", resource="device_descriptions", file_name=file_name)
+    assert dev_desc
+    return dev_desc

aiohomematic_test_support-2025.10.16/support.py → aiohomematic_test_support-2025.10.17/mock.py

@@ -4,169 +4,27 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from collections.abc import AsyncGenerator
-import contextlib
-import importlib.resources
 import json
 import logging
 import os
-from typing import Any, Self, cast
-from unittest.mock import MagicMock, Mock, patch
+from typing import Any, cast
+from unittest.mock import MagicMock, Mock
 import zipfile
 
 from aiohttp import ClientSession
 import orjson
 
-from aiohomematic.central import CentralConfig, CentralUnit
-from aiohomematic.client import BaseRpcProxy, Client, ClientConfig, InterfaceConfig
+from aiohomematic.central import CentralUnit
+from aiohomematic.client import BaseRpcProxy
 from aiohomematic.client.json_rpc import _JsonKey, _JsonRpcMethod
 from aiohomematic.client.rpc_proxy import _RpcMethod
-from aiohomematic.const import (
-    LOCAL_HOST,
-    UTF_8,
-    BackendSystemEvent,
-    DataOperationResult,
-    Interface,
-    Parameter,
-    ParamsetKey,
-    RPCType,
-)
-from aiohomematic.model.custom import CustomDataPoint
+from aiohomematic.const import UTF_8, DataOperationResult, Parameter, ParamsetKey, RPCType
 from aiohomematic.store.persistent import _freeze_params, _unfreeze_params
 from aiohomematic_test_support import const
 
 _LOGGER = logging.getLogger(__name__)
 
-
 # pylint: disable=protected-access
-class FactoryWithClient:
-    """Factory for a central with one local client."""
-
-    def __init__(
-        self,
-        *,
-        player: SessionPlayer,
-        address_device_translation: set[str] | None = None,
-        do_mock_client: bool = True,
-        exclude_methods_from_mocks: set[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-        ignore_devices_on_create: list[str] | None = None,
-        include_properties_in_mocks: set[str] | None = None,
-        interface_configs: set[InterfaceConfig] | None = None,
-        un_ignore_list: list[str] | None = None,
-    ) -> None:
-        """Init the central factory."""
-        self._player = player
-        self.init(
-            address_device_translation=address_device_translation,
-            do_mock_client=do_mock_client,
-            exclude_methods_from_mocks=exclude_methods_from_mocks,
-            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-            ignore_devices_on_create=ignore_devices_on_create,
-            include_properties_in_mocks=include_properties_in_mocks,
-            interface_configs=interface_configs,
-            un_ignore_list=un_ignore_list,
-        )
-        self.system_event_mock = MagicMock()
-        self.ha_event_mock = MagicMock()
-
-    def init(
-        self,
-        *,
-        address_device_translation: set[str] | None = None,
-        do_mock_client: bool = True,
-        exclude_methods_from_mocks: set[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-        ignore_devices_on_create: list[str] | None = None,
-        include_properties_in_mocks: set[str] | None = None,
-        interface_configs: set[InterfaceConfig] | None = None,
-        un_ignore_list: list[str] | None = None,
-    ) -> Self:
-        """Init the central factory."""
-        self._address_device_translation = address_device_translation
-        self._do_mock_client = do_mock_client
-        self._exclude_methods_from_mocks = exclude_methods_from_mocks
-        self._ignore_custom_device_definition_models = ignore_custom_device_definition_models
-        self._ignore_devices_on_create = ignore_devices_on_create
-        self._include_properties_in_mocks = include_properties_in_mocks
-        self._interface_configs = (
-            interface_configs
-            if interface_configs is not None
-            else {
-                InterfaceConfig(
-                    central_name=const.CENTRAL_NAME,
-                    interface=Interface.BIDCOS_RF,
-                    port=2001,
-                )
-            }
-        )
-        self._un_ignore_list = frozenset(un_ignore_list or [])
-        self._client_session = _get_client_session(
-            player=self._player,
-            address_device_translation=self._address_device_translation,
-            ignore_devices_on_create=self._ignore_devices_on_create,
-        )
-        self._xml_proxy = _get_xml_rpc_proxy(
-            player=self._player,
-            address_device_translation=self._address_device_translation,
-            ignore_devices_on_create=self._ignore_devices_on_create,
-        )
-        return self
-
-    async def get_raw_central(self) -> CentralUnit:
-        """Return a central based on give address_device_translation."""
-        interface_configs = self._interface_configs if self._interface_configs else set()
-        central = CentralConfig(
-            name=const.CENTRAL_NAME,
-            host=const.CCU_HOST,
-            username=const.CCU_USERNAME,
-            password=const.CCU_PASSWORD,
-            central_id="test1234",
-            interface_configs=interface_configs,
-            client_session=self._client_session,
-            un_ignore_list=self._un_ignore_list,
-            ignore_custom_device_definition_models=frozenset(self._ignore_custom_device_definition_models or []),
-            start_direct=True,
-        ).create_central()
-
-        central.register_backend_system_callback(cb=self.system_event_mock)
-        central.register_homematic_callback(cb=self.ha_event_mock)
-
-        assert central
-        self._client_session.set_central(central=central)  # type: ignore[attr-defined]
-        self._xml_proxy.set_central(central=central)
-        return central
-
-    async def get_default_central(self, *, start: bool = True) -> CentralUnit:
-        """Return a central based on give address_device_translation."""
-        central = await self.get_raw_central()
-
-        await self._xml_proxy.do_init()
-        patch("aiohomematic.client.ClientConfig._create_xml_rpc_proxy", return_value=self._xml_proxy).start()
-        patch("aiohomematic.central.CentralUnit._identify_ip_addr", return_value=LOCAL_HOST).start()
-
-        # Optionally patch client creation to return a mocked client
-        if self._do_mock_client:
-            _orig_create_client = ClientConfig.create_client
-
-            async def _mocked_create_client(config: ClientConfig) -> Client | Mock:
-                real_client = await _orig_create_client(config)
-                return cast(
-                    Mock,
-                    get_mock(
-                        instance=real_client,
-                        exclude_methods=self._exclude_methods_from_mocks,
-                        include_properties=self._include_properties_in_mocks,
-                    ),
-                )
-
-            patch("aiohomematic.client.ClientConfig.create_client", _mocked_create_client).start()
-
-        if start:
-            await central.start()
-            await central._init_hub()
-        assert central
-        return central
 
 
 def _get_not_mockable_method_names(instance: Any, exclude_methods: set[str]) -> set[str]:
@@ -191,17 +49,7 @@ def _get_properties(data_object: Any, decorator: Any) -> set[str]:
     return {y for y in dir(cls) if isinstance(getattr(cls, y), resolved_decorator)}
 
 
-def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
-    """Load json file from disk into dict."""
-    package_path = str(importlib.resources.files(anchor))
-    with open(
-        file=os.path.join(package_path, resource, file_name),
-        encoding=UTF_8,
-    ) as fptr:
-        return orjson.loads(fptr.read())
-
-
-def _get_client_session(  # noqa: C901
+def get_client_session(  # noqa: C901
     *,
     player: SessionPlayer,
     address_device_translation: set[str] | None = None,
@@ -337,7 +185,7 @@ def _get_client_session(  # noqa: C901
     return cast(ClientSession, _MockClientSession())
 
 
-def _get_xml_rpc_proxy(  # noqa: C901
+def get_xml_rpc_proxy(  # noqa: C901
     *,
     player: SessionPlayer,
     address_device_translation: set[str] | None = None,
@@ -478,33 +326,6 @@ def _get_xml_rpc_proxy(  # noqa: C901
     return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
-async def get_central_client_factory(
-    player: SessionPlayer,
-    address_device_translation: set[str],
-    do_mock_client: bool,
-    ignore_devices_on_create: list[str] | None,
-    ignore_custom_device_definition_models: list[str] | None,
-    un_ignore_list: list[str] | None,
-) -> AsyncGenerator[tuple[CentralUnit, Client | Mock, FactoryWithClient]]:
-    """Return central factory."""
-    factory = FactoryWithClient(
-        player=player,
-        address_device_translation=address_device_translation,
-        do_mock_client=do_mock_client,
-        ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-        ignore_devices_on_create=ignore_devices_on_create,
-        un_ignore_list=un_ignore_list,
-    )
-    central = await factory.get_default_central()
-    client = central.primary_client
-    assert client
-    try:
-        yield central, client, factory
-    finally:
-        await central.stop()
-        await central.clear_files()
-
-
 def get_mock(
     instance: Any, exclude_methods: set[str] | None = None, include_properties: set[str] | None = None, **kwargs: Any
 ) -> Any:
@@ -532,62 +353,6 @@ def get_mock(
     return mock
 
 
-def get_prepared_custom_data_point(central: CentralUnit, address: str, channel_no: int) -> CustomDataPoint | None:
-    """Return the hm custom_data_point."""
-    if cdp := central.get_custom_data_point(address=address, channel_no=channel_no):
-        for dp in cdp._data_points.values():
-            dp._state_uncertain = False
-        return cdp
-    return None
-
-
-async def get_pydev_ccu_central_unit_full(
-    port: int,
-    client_session: ClientSession | None = None,
-) -> CentralUnit:
-    """Create and yield central, after all devices have been created."""
-    device_event = asyncio.Event()
-
-    def systemcallback(system_event: Any, *args: Any, **kwargs: Any) -> None:
-        if system_event == BackendSystemEvent.DEVICES_CREATED:
-            device_event.set()
-
-    interface_configs = {
-        InterfaceConfig(
-            central_name=const.CENTRAL_NAME,
-            interface=Interface.BIDCOS_RF,
-            port=port,
-        )
-    }
-
-    central = CentralConfig(
-        name=const.CENTRAL_NAME,
-        host=const.CCU_HOST,
-        username=const.CCU_USERNAME,
-        password=const.CCU_PASSWORD,
-        central_id="test1234",
-        interface_configs=interface_configs,
-        client_session=client_session,
-        program_markers=(),
-        sysvar_markers=(),
-    ).create_central()
-    central.register_backend_system_callback(cb=systemcallback)
-    await central.start()
-
-    # Wait up to 60 seconds for the DEVICES_CREATED event which signals that all devices are available
-    with contextlib.suppress(TimeoutError):
-        await asyncio.wait_for(device_event.wait(), timeout=60)
-
-    return central
-
-
-def load_device_description(file_name: str) -> Any:
-    """Load device description."""
-    dev_desc = _load_json_file(anchor="pydevccu", resource="device_descriptions", file_name=file_name)
-    assert dev_desc
-    return dev_desc
-
-
 async def get_session_player(*, file_name: str) -> SessionPlayer:
     """Provide a SessionPlayer preloaded from the randomized full session JSON file."""
     player = SessionPlayer(file_id=file_name)

aiohomematic_test_support-2025.10.16/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"