python-duco-connectivity 0.8.0__tar.gz → 0.9.0__tar.gz

{python_duco_connectivity-0.8.0/src/python_duco_connectivity.egg-info → python_duco_connectivity-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.8.0
+Version: 0.9.0
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT
@@ -64,6 +64,8 @@ in the development examples below.
 - asynchronous communication via `aiohttp`
 - typed stable config families for the documented `/config` branches
 - typed helpers for stable `/info` fields such as heat recovery filter time
+- optional temperature helpers that return `None` when the box reports their
+  endpoint as unavailable
 - typed models that stay close to the API response shape
 - preserved `raw_payload` data on typed response models for forward compatibility
 

{python_duco_connectivity-0.8.0 → python_duco_connectivity-0.9.0}/README.md

@@ -32,6 +32,8 @@ in the development examples below.
 - asynchronous communication via `aiohttp`
 - typed stable config families for the documented `/config` branches
 - typed helpers for stable `/info` fields such as heat recovery filter time
+- optional temperature helpers that return `None` when the box reports their
+  endpoint as unavailable
 - typed models that stay close to the API response shape
 - preserved `raw_payload` data on typed response models for forward compatibility
 

{python_duco_connectivity-0.8.0 → python_duco_connectivity-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-duco-connectivity"
-version = "0.8.0"
+version = "0.9.0"
 description = "Async HTTP client for the local Duco Connectivity API"
 readme = "README.md"
 license = "MIT"

{python_duco_connectivity-0.8.0 → python_duco_connectivity-0.9.0}/src/duco_connectivity/client.py

@@ -105,6 +105,23 @@ def _compat_caller() -> str | None:
     return None
 
 
+def _is_unsupported_optional_endpoint_error(error: DucoResponseError, path: str) -> bool:
+    """Return whether a Duco response reports an unavailable optional endpoint."""
+    if error.status != 400 or error.path != path:
+        return False
+
+    try:
+        error_payload = cast(object, json.loads(error.body))
+    except json.JSONDecodeError:
+        return False
+
+    if not isinstance(error_payload, dict):
+        return False
+
+    response = cast(dict[str, object], error_payload)
+    return response.get("Code") == 3 and response.get("Result") == "FAILED"
+
+
 class DucoClient:
     """Client for a Duco box that exposes the local HTTP API."""
 
@@ -2191,18 +2208,8 @@ class DucoClient:
         try:
             payload = await self.async_get_info(module=InfoModuleSelector.HEAT_RECOVERY)
         except DucoResponseError as err:
-            if err.status == 400 and err.path == "/info":
-                try:
-                    error_payload = json.loads(err.body)
-                except json.JSONDecodeError:
-                    pass
-                else:
-                    if (
-                        isinstance(error_payload, dict)
-                        and error_payload.get("Code") == 3
-                        and error_payload.get("Result") == "FAILED"
-                    ):
-                        return None
+            if _is_unsupported_optional_endpoint_error(err, "/info"):
+                return None
             raise
 
         if not isinstance(payload, dict):
@@ -2235,9 +2242,14 @@ class DucoClient:
             path="HeatRecovery.General",
         )
 
-    async def async_get_ventilation_temperature_info(self) -> VentilationTemperatureInfo:
-        """Return ventilation temperatures from `/info?module=Ventilation` in Celsius."""
-        payload = await self.async_get_info(module=InfoModuleSelector.VENTILATION)
+    async def async_get_ventilation_temperature_info(self) -> VentilationTemperatureInfo | None:
+        """Return ventilation temperatures when the box exposes them, in Celsius."""
+        try:
+            payload = await self.async_get_info(module=InfoModuleSelector.VENTILATION)
+        except DucoResponseError as err:
+            if _is_unsupported_optional_endpoint_error(err, "/info"):
+                return None
+            raise
 
         if not isinstance(payload, dict):
             msg = (
@@ -2281,11 +2293,16 @@ class DucoClient:
     ) -> BypassSupplyTemperatureTarget | None:
         """Return a bypass supply target from `/config` in Celsius."""
         parameter = self._validate_bypass_zone_id(zone_id)
-        config = await self.async_get_config(
-            module=ConfigModuleSelector.HEAT_RECOVERY,
-            submodule=ConfigHeatRecoverySubmoduleSelector.BYPASS,
-            parameter=parameter,
-        )
+        try:
+            config = await self.async_get_config(
+                module=ConfigModuleSelector.HEAT_RECOVERY,
+                submodule=ConfigHeatRecoverySubmoduleSelector.BYPASS,
+                parameter=parameter,
+            )
+        except DucoResponseError as err:
+            if _is_unsupported_optional_endpoint_error(err, "/config"):
+                return None
+            raise
         return self._extract_bypass_supply_temperature_target(config, zone_id)
 
     async def async_set_bypass_supply_temperature_target(

{python_duco_connectivity-0.8.0 → python_duco_connectivity-0.9.0/src/python_duco_connectivity.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.8.0
+Version: 0.9.0
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT
@@ -64,6 +64,8 @@ in the development examples below.
 - asynchronous communication via `aiohttp`
 - typed stable config families for the documented `/config` branches
 - typed helpers for stable `/info` fields such as heat recovery filter time
+- optional temperature helpers that return `None` when the box reports their
+  endpoint as unavailable
 - typed models that stay close to the API response shape
 - preserved `raw_payload` data on typed response models for forward compatibility
 

{python_duco_connectivity-0.8.0 → python_duco_connectivity-0.9.0}/tests/test_client.py

@@ -3688,6 +3688,34 @@ async def test_get_ventilation_temperature_info_returns_empty_model_when_sensor_
     assert payload.raw_payload == {}
 
 
+async def test_get_ventilation_temperature_info_returns_none_when_module_unsupported() -> None:
+    """Unsupported ventilation modules should be treated as an absent optional capability."""
+    mock_response = _response(
+        status=400,
+        text_payload='{"Code":3,"Result":"FAILED"}',
+    )
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with patch.object(session, "request", _request(mock_response)):
+            payload = await client.async_get_ventilation_temperature_info()
+
+    assert payload is None
+
+
+async def test_get_ventilation_temperature_info_reraises_other_client_errors() -> None:
+    """Unexpected ventilation endpoint failures should remain visible to callers."""
+    mock_response = _response(status=400, text_payload='{"Code":4,"Result":"FAILED"}')
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with (
+            patch.object(session, "request", _request(mock_response)),
+            pytest.raises(DucoResponseError),
+        ):
+            await client.async_get_ventilation_temperature_info()
+
+
 @pytest.mark.parametrize(
     ("payload", "message"),
     [
@@ -3772,6 +3800,34 @@ async def test_get_bypass_supply_temperature_target_returns_none_when_not_report
     assert payload is None
 
 
+async def test_get_bypass_supply_temperature_target_returns_none_when_unsupported() -> None:
+    """Unsupported bypass targets should be treated as an absent optional capability."""
+    mock_response = _response(
+        status=400,
+        text_payload='{"Code":3,"Result":"FAILED"}',
+    )
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with patch.object(session, "request", _request(mock_response)):
+            payload = await client.async_get_bypass_supply_temperature_target(1)
+
+    assert payload is None
+
+
+async def test_get_bypass_supply_temperature_target_reraises_other_client_errors() -> None:
+    """Unexpected bypass target failures should remain visible to callers."""
+    mock_response = _response(status=400, text_payload='{"Code":4,"Result":"FAILED"}')
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with (
+            patch.object(session, "request", _request(mock_response)),
+            pytest.raises(DucoResponseError),
+        ):
+            await client.async_get_bypass_supply_temperature_target(1)
+
+
 @pytest.mark.parametrize("zone_id", [0, 9, "1"])
 async def test_bypass_supply_temperature_helpers_reject_invalid_zone_ids(zone_id: object) -> None:
     """Bypass target helpers should validate the supported zone range."""