aiohomematic-test-support 2025.11.3__tar.gz → 2025.11.11__tar.gz

{aiohomematic_test_support-2025.11.3/aiohomematic_test_support.egg-info → aiohomematic_test_support-2025.11.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.11.3
+Version: 2025.11.11
 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.11.3 → aiohomematic_test_support-2025.11.11}/__init__.py

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

{aiohomematic_test_support-2025.11.3 → aiohomematic_test_support-2025.11.11/aiohomematic_test_support.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.11.3
+Version: 2025.11.11
 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.11.3 → aiohomematic_test_support-2025.11.11}/mock.py

@@ -63,9 +63,9 @@ def get_client_session(  # noqa: C901
     """
 
     class _MockResponse:
-        def __init__(self, *, json_data: dict | None) -> None:
+        def __init__(self, *, json_data: dict[str, Any] | None) -> None:
             # If no match is found, emulate backend error payload
-            self._json = json_data or {
+            self._json: dict[str, Any] = json_data or {
                 _JsonKey.RESULT: None,
                 _JsonKey.ERROR: {"name": "-1", "code": -1, "message": "Not found in session player"},
                 _JsonKey.ID: 0,
@@ -83,9 +83,8 @@ def get_client_session(  # noqa: C901
             """Initialize the mock client session."""
             self._central: CentralUnit | None = None
 
-        def set_central(self, *, central: CentralUnit) -> None:
-            """Set the central."""
-            self._central = central
+        async def close(self) -> None:  # compatibility
+            return None
 
         async def post(
             self,
@@ -187,8 +186,9 @@ def get_client_session(  # noqa: C901
                 json_data[_JsonKey.RESULT] = new_devices
             return _MockResponse(json_data=json_data)
 
-        async def close(self) -> None:  # compatibility
-            return None
+        def set_central(self, *, central: CentralUnit) -> None:
+            """Set the central."""
+            self._central = central
 
     return cast(ClientSession, _MockClientSession())
 
@@ -212,29 +212,40 @@ def get_xml_rpc_proxy(  # noqa: C901
             self._name = full_name
             self._caller = caller
 
-        def __getattr__(self, sub: str) -> _Method:
-            # Allow chaining like proxy.system.listMethods
-            return _Method(f"{self._name}.{sub}", self._caller)
-
         async def __call__(self, *args: Any) -> Any:
             # Forward to caller with collected method name and positional params
             return await self._caller(self._name, *args)
 
+        def __getattr__(self, sub: str) -> _Method:
+            # Allow chaining like proxy.system.listMethods
+            return _Method(f"{self._name}.{sub}", self._caller)
+
     class _AioXmlRpcProxyFromSession:
         def __init__(self) -> None:
             self._player = player
             self._supported_methods: tuple[str, ...] = ()
             self._central: CentralUnit | None = None
 
-        def set_central(self, *, central: CentralUnit) -> None:
-            """Set the central."""
-            self._central = central
+        def __getattr__(self, name: str) -> Any:
+            # Start of method chain
+            return _Method(name, self._invoke)
 
         @property
         def supported_methods(self) -> tuple[str, ...]:
             """Return the supported methods."""
             return self._supported_methods
 
+        async def clientServerInitialized(self, interface_id: str) -> None:
+            """Answer clientServerInitialized with pong."""
+            await self.ping(callerId=interface_id)
+
+        async def do_init(self) -> None:
+            """Init the xml rpc proxy."""
+            if supported_methods := await self.system.listMethods():
+                # ping is missing in VirtualDevices interface but can be used.
+                supported_methods.append(_RpcMethod.PING)
+                self._supported_methods = tuple(supported_methods)
+
         async def getAllSystemVariables(self) -> dict[str, Any]:
             """Return all system variables."""
             return const.SYSVAR_DATA_XML
@@ -249,41 +260,6 @@ def get_xml_rpc_proxy(  # noqa: C901
                 )
                 return result if result else {}
 
-        async def setValue(self, channel_address: str, parameter: str, value: Any, rx_mode: Any | None = None) -> None:
-            """Set a value."""
-            if self._central:
-                await self._central.data_point_event(
-                    interface_id=self._central.primary_client.interface_id,  # type: ignore[union-attr]
-                    channel_address=channel_address,
-                    parameter=parameter,
-                    value=value,
-                )
-
-        async def putParamset(
-            self, channel_address: str, paramset_key: str, values: Any, rx_mode: Any | None = None
-        ) -> None:
-            """Set a paramset."""
-            if self._central and paramset_key == ParamsetKey.VALUES:
-                interface_id = self._central.primary_client.interface_id  # type: ignore[union-attr]
-                for param, value in values.items():
-                    await self._central.data_point_event(
-                        interface_id=interface_id, channel_address=channel_address, parameter=param, value=value
-                    )
-
-        async def ping(self, callerId: str) -> None:
-            """Answer ping with pong."""
-            if self._central:
-                await self._central.data_point_event(
-                    interface_id=callerId,
-                    channel_address="",
-                    parameter=Parameter.PONG,
-                    value=callerId,
-                )
-
-        async def clientServerInitialized(self, interface_id: str) -> None:
-            """Answer clientServerInitialized with pong."""
-            await self.ping(callerId=interface_id)
-
         async def listDevices(self) -> list[Any]:
             """Return a list of devices."""
             devices = self._player.get_latest_response_by_params(
@@ -309,9 +285,43 @@ def get_xml_rpc_proxy(  # noqa: C901
 
             return new_devices
 
-        def __getattr__(self, name: str) -> Any:
-            # Start of method chain
-            return _Method(name, self._invoke)
+        async def ping(self, callerId: str) -> None:
+            """Answer ping with pong."""
+            if self._central:
+                await self._central.data_point_event(
+                    interface_id=callerId,
+                    channel_address="",
+                    parameter=Parameter.PONG,
+                    value=callerId,
+                )
+
+        async def putParamset(
+            self, channel_address: str, paramset_key: str, values: Any, rx_mode: Any | None = None
+        ) -> None:
+            """Set a paramset."""
+            if self._central and paramset_key == ParamsetKey.VALUES:
+                interface_id = self._central.primary_client.interface_id  # type: ignore[union-attr]
+                for param, value in values.items():
+                    await self._central.data_point_event(
+                        interface_id=interface_id, channel_address=channel_address, parameter=param, value=value
+                    )
+
+        async def setValue(self, channel_address: str, parameter: str, value: Any, rx_mode: Any | None = None) -> None:
+            """Set a value."""
+            if self._central:
+                await self._central.data_point_event(
+                    interface_id=self._central.primary_client.interface_id,  # type: ignore[union-attr]
+                    channel_address=channel_address,
+                    parameter=parameter,
+                    value=value,
+                )
+
+        def set_central(self, *, central: CentralUnit) -> None:
+            """Set the central."""
+            self._central = central
+
+        async def stop(self) -> None:  # compatibility with AioXmlRpcProxy.stop
+            return None
 
         async def _invoke(self, method: str, *args: Any) -> Any:
             params = tuple(args)
@@ -321,16 +331,6 @@ def get_xml_rpc_proxy(  # noqa: C901
                 params=params,
             )
 
-        async def stop(self) -> None:  # compatibility with AioXmlRpcProxy.stop
-            return None
-
-        async def do_init(self) -> None:
-            """Init the xml rpc proxy."""
-            if supported_methods := await self.system.listMethods():
-                # ping is missing in VirtualDevices interface but can be used.
-                supported_methods.append(_RpcMethod.PING)
-                self._supported_methods = tuple(supported_methods)
-
     return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
@@ -389,45 +389,23 @@ class SessionPlayer:
         """Return the secondary store for the given file_id."""
         return [fid for fid in self._store if fid != self._file_id]
 
-    def supports_file_id(self, *, file_id: str) -> bool:
-        """Return whether the session player supports the given file_id."""
-        return file_id in self._store
-
-    async def load(self, *, file_path: str, file_id: str) -> DataOperationResult:
-        """
-        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 self.supports_file_id(file_id=file_id):
-            return DataOperationResult.NO_LOAD
-
-        if not os.path.exists(file_path):
-            return DataOperationResult.NO_LOAD
-
-        def _perform_load() -> DataOperationResult:
-            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)
-                else:
-                    with open(file=file_path, encoding=UTF_8) as file_pointer:
-                        data = json.loads(file_pointer.read())
-
-                self._store[file_id] = data
-            except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
-                return DataOperationResult.LOAD_FAIL
-            return DataOperationResult.LOAD_SUCCESS
+    def get_latest_response_by_method(self, *, rpc_type: str, method: str) -> list[tuple[Any, Any]]:
+        """Return latest non-expired responses for a given (rpc_type, method)."""
+        if pri_result := self.get_latest_response_by_method_for_file_id(
+            file_id=self._file_id,
+            rpc_type=rpc_type,
+            method=method,
+        ):
+            return pri_result
 
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, _perform_load)
+        for secondary_file_id in self._secondary_file_ids:
+            if sec_result := self.get_latest_response_by_method_for_file_id(
+                file_id=secondary_file_id,
+                rpc_type=rpc_type,
+                method=method,
+            ):
+                return sec_result
+        return pri_result
 
     def get_latest_response_by_method_for_file_id(
         self, *, file_id: str, rpc_type: str, method: str
@@ -453,20 +431,28 @@ class SessionPlayer:
             result.append((params, resp))
         return result
 
-    def get_latest_response_by_method(self, *, rpc_type: str, method: str) -> list[tuple[Any, Any]]:
-        """Return latest non-expired responses for a given (rpc_type, method)."""
-        if pri_result := self.get_latest_response_by_method_for_file_id(
+    def get_latest_response_by_params(
+        self,
+        *,
+        rpc_type: str,
+        method: str,
+        params: Any,
+    ) -> Any:
+        """Return latest non-expired responses for a given (rpc_type, method, params)."""
+        if pri_result := self.get_latest_response_by_params_for_file_id(
             file_id=self._file_id,
             rpc_type=rpc_type,
             method=method,
+            params=params,
         ):
             return pri_result
 
         for secondary_file_id in self._secondary_file_ids:
-            if sec_result := self.get_latest_response_by_method_for_file_id(
+            if sec_result := self.get_latest_response_by_params_for_file_id(
                 file_id=secondary_file_id,
                 rpc_type=rpc_type,
                 method=method,
+                params=params,
             ):
                 return sec_result
         return pri_result
@@ -497,28 +483,42 @@ class SessionPlayer:
         except ValueError:
             return None
 
-    def get_latest_response_by_params(
-        self,
-        *,
-        rpc_type: str,
-        method: str,
-        params: Any,
-    ) -> Any:
-        """Return latest non-expired responses for a given (rpc_type, method, params)."""
-        if pri_result := self.get_latest_response_by_params_for_file_id(
-            file_id=self._file_id,
-            rpc_type=rpc_type,
-            method=method,
-            params=params,
-        ):
-            return pri_result
+    async def load(self, *, file_path: str, file_id: str) -> DataOperationResult:
+        """
+        Load data from disk into the dictionary.
 
-        for secondary_file_id in self._secondary_file_ids:
-            if sec_result := self.get_latest_response_by_params_for_file_id(
-                file_id=secondary_file_id,
-                rpc_type=rpc_type,
-                method=method,
-                params=params,
-            ):
-                return sec_result
-        return pri_result
+        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 self.supports_file_id(file_id=file_id):
+            return DataOperationResult.NO_LOAD
+
+        if not os.path.exists(file_path):
+            return DataOperationResult.NO_LOAD
+
+        def _perform_load() -> DataOperationResult:
+            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)
+                else:
+                    with open(file=file_path, encoding=UTF_8) as file_pointer:
+                        data = json.loads(file_pointer.read())
+
+                self._store[file_id] = data
+            except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
+                return DataOperationResult.LOAD_FAIL
+            return DataOperationResult.LOAD_SUCCESS
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, _perform_load)
+
+    def supports_file_id(self, *, file_id: str) -> bool:
+        """Return whether the session player supports the given file_id."""
+        return file_id in self._store

{aiohomematic_test_support-2025.11.3 → aiohomematic_test_support-2025.11.11}/factory.py

@@ -52,6 +52,62 @@ class FactoryWithClient:
         self.system_event_mock = MagicMock()
         self.ha_event_mock = MagicMock()
 
+    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_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,
+            optional_settings=(OptionalSettings.ENABLE_LINKED_ENTITY_CLIMATE_ACTIVITY,),
+        ).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
+
     def init(
         self,
         *,
@@ -95,62 +151,6 @@ class FactoryWithClient:
         )
         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,
-            optional_settings=(OptionalSettings.ENABLE_LINKED_ENTITY_CLIMATE_ACTIVITY,),
-        ).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(
     *,