python-duco-connectivity 0.10.0__tar.gz → 0.12.0__tar.gz

{python_duco_connectivity-0.10.0/src/python_duco_connectivity.egg-info → python_duco_connectivity-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.10.0
+Version: 0.12.0
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT
@@ -76,8 +76,9 @@ bypass-target endpoint is unsupported, the relevant helper raises
 subclass and preserves the HTTP status, path, and response body. A valid
 ventilation-temperature response always returns a `VentilationTemperatureInfo`
 model, whose individual temperature fields can be `None` when omitted. The
-bypass-target helper returns `None` when its target is omitted from a valid
-response.
+bypass-target helper returns a typed target model for successful parameter-
+specific reads and raises `DucoError` if the requested target field is missing
+from an otherwise valid `/config` response.
 
 Diagnostic subsystem reads now keep raw component and status strings from
 `Diag.SubSystems`, so future subsystem names or status values remain available
@@ -183,6 +184,7 @@ For local function probes without activating the environment first:
 .venv/bin/python -m duco_connectivity --host 192.168.1.10 call async_get_board_info
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_board_info
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_ventilation_temperature_info
+.venv/bin/duco-probe --host 192.168.1.10 call async_get_bypass_supply_temperature_targets
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_bypass_supply_temperature_target --kwargs '{"zone_id": 1}'
 ```
 

{python_duco_connectivity-0.10.0 → python_duco_connectivity-0.12.0}/README.md

@@ -44,8 +44,9 @@ bypass-target endpoint is unsupported, the relevant helper raises
 subclass and preserves the HTTP status, path, and response body. A valid
 ventilation-temperature response always returns a `VentilationTemperatureInfo`
 model, whose individual temperature fields can be `None` when omitted. The
-bypass-target helper returns `None` when its target is omitted from a valid
-response.
+bypass-target helper returns a typed target model for successful parameter-
+specific reads and raises `DucoError` if the requested target field is missing
+from an otherwise valid `/config` response.
 
 Diagnostic subsystem reads now keep raw component and status strings from
 `Diag.SubSystems`, so future subsystem names or status values remain available
@@ -151,6 +152,7 @@ For local function probes without activating the environment first:
 .venv/bin/python -m duco_connectivity --host 192.168.1.10 call async_get_board_info
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_board_info
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_ventilation_temperature_info
+.venv/bin/duco-probe --host 192.168.1.10 call async_get_bypass_supply_temperature_targets
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_bypass_supply_temperature_target --kwargs '{"zone_id": 1}'
 ```
 

{python_duco_connectivity-0.10.0 → python_duco_connectivity-0.12.0}/pyproject.toml

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

{python_duco_connectivity-0.10.0 → python_duco_connectivity-0.12.0}/src/duco_connectivity/client.py

@@ -400,6 +400,19 @@ class DucoClient:
 
         return cls._build_bypass_supply_temperature_target(zone_id, raw_value)
 
+    @classmethod
+    def _extract_bypass_supply_temperature_targets(
+        cls,
+        config: Config,
+    ) -> dict[int, BypassSupplyTemperatureTarget]:
+        """Read all bypass supply targets from a typed config response."""
+        return {
+            zone_id: target
+            for zone_id in range(1, 9)
+            if (target := cls._extract_bypass_supply_temperature_target(config, zone_id))
+            is not None
+        }
+
     @staticmethod
     def _read_scalar_value(payload: dict[str, Any], key: str) -> Any:
         raw_value = payload[key]
@@ -2295,7 +2308,7 @@ class DucoClient:
     async def async_get_bypass_supply_temperature_target(
         self,
         zone_id: int,
-    ) -> BypassSupplyTemperatureTarget | None:
+    ) -> BypassSupplyTemperatureTarget:
         """Return a bypass supply target from `/config` in Celsius."""
         parameter = self._validate_bypass_zone_id(zone_id)
         try:
@@ -2312,7 +2325,30 @@ class DucoClient:
                     err.body,
                 ) from err
             raise
-        return self._extract_bypass_supply_temperature_target(config, zone_id)
+        target = self._extract_bypass_supply_temperature_target(config, zone_id)
+        if target is None:
+            msg = f"Expected {parameter} in /config response"
+            raise DucoError(msg)
+        return target
+
+    async def async_get_bypass_supply_temperature_targets(
+        self,
+    ) -> dict[int, BypassSupplyTemperatureTarget]:
+        """Return all bypass supply targets exposed through `/config` in Celsius."""
+        try:
+            config = await self.async_get_config(
+                module=ConfigModuleSelector.HEAT_RECOVERY,
+                submodule=ConfigHeatRecoverySubmoduleSelector.BYPASS,
+            )
+        except DucoResponseError as err:
+            if _is_unsupported_optional_endpoint_error(err, "/config"):
+                raise DucoUnsupportedCapabilityError(
+                    err.status,
+                    err.path,
+                    err.body,
+                ) from err
+            raise
+        return self._extract_bypass_supply_temperature_targets(config)
 
     async def async_set_bypass_supply_temperature_target(
         self,

{python_duco_connectivity-0.10.0 → python_duco_connectivity-0.12.0/src/python_duco_connectivity.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.10.0
+Version: 0.12.0
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT
@@ -76,8 +76,9 @@ bypass-target endpoint is unsupported, the relevant helper raises
 subclass and preserves the HTTP status, path, and response body. A valid
 ventilation-temperature response always returns a `VentilationTemperatureInfo`
 model, whose individual temperature fields can be `None` when omitted. The
-bypass-target helper returns `None` when its target is omitted from a valid
-response.
+bypass-target helper returns a typed target model for successful parameter-
+specific reads and raises `DucoError` if the requested target field is missing
+from an otherwise valid `/config` response.
 
 Diagnostic subsystem reads now keep raw component and status strings from
 `Diag.SubSystems`, so future subsystem names or status values remain available
@@ -183,6 +184,7 @@ For local function probes without activating the environment first:
 .venv/bin/python -m duco_connectivity --host 192.168.1.10 call async_get_board_info
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_board_info
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_ventilation_temperature_info
+.venv/bin/duco-probe --host 192.168.1.10 call async_get_bypass_supply_temperature_targets
 .venv/bin/duco-probe --host 192.168.1.10 call async_get_bypass_supply_temperature_target --kwargs '{"zone_id": 1}'
 ```
 

{python_duco_connectivity-0.10.0 → python_duco_connectivity-0.12.0}/tests/test_api_reference.py

@@ -90,7 +90,7 @@ def test_api_reference_documents_optional_capability_contracts() -> None:
     content = render_api_reference()
 
     assert "optional endpoint as unsupported" in content
-    assert "target is omitted from an otherwise valid response" in content
+    assert "without the requested target field in the response" in content
     assert "optional target endpoint is unsupported" in content
 
 

{python_duco_connectivity-0.10.0 → python_duco_connectivity-0.12.0}/tests/test_client.py

@@ -3794,16 +3794,95 @@ async def test_get_bypass_supply_temperature_target_returns_converted_values(
     }
 
 
-async def test_get_bypass_supply_temperature_target_returns_none_when_not_reported() -> None:
-    """Missing bypass targets should return None instead of failing."""
+async def test_get_bypass_supply_temperature_targets_returns_available_targets(
+    config_data: dict[str, object],
+) -> None:
+    """Bulk bypass target reads should return all available targets in Celsius."""
+    mock_response = _response(json_payload=config_data)
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        request_mock = _request(mock_response)
+        with patch.object(session, "request", request_mock):
+            targets = await client.async_get_bypass_supply_temperature_targets()
+
+    assert targets == {
+        1: BypassSupplyTemperatureTarget(
+            zone_id=1,
+            value=18.0,
+            minimum=12.0,
+            increment=0.5,
+            maximum=22.0,
+        ),
+        2: BypassSupplyTemperatureTarget(
+            zone_id=2,
+            value=18.5,
+            minimum=12.0,
+            increment=0.5,
+            maximum=22.0,
+        ),
+    }
+    assert request_mock.call_args.kwargs["params"] == {
+        "module": "HeatRecovery",
+        "submodule": "Bypass",
+    }
+
+
+async def test_get_bypass_supply_temperature_targets_returns_empty_when_absent() -> None:
+    """Bulk bypass target reads should omit targets absent from the response."""
     mock_response = _response(json_payload={"HeatRecovery": {"Bypass": {}}})
 
     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)
+            targets = await client.async_get_bypass_supply_temperature_targets()
 
-    assert payload is None
+    assert targets == {}
+
+
+async def test_get_bypass_supply_temperature_targets_raises_when_unsupported() -> None:
+    """Unsupported bulk bypass target reads should raise a typed capability error."""
+    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)),
+            pytest.raises(DucoUnsupportedCapabilityError),
+        ):
+            await client.async_get_bypass_supply_temperature_targets()
+
+
+async def test_get_bypass_supply_temperature_targets_reraises_other_client_errors() -> None:
+    """Unexpected bulk 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_targets()
+
+
+async def test_get_bypass_supply_temperature_target_raises_when_not_reported() -> None:
+    """Missing bypass targets should fail for parameter-specific helper reads."""
+    mock_response = _response(json_payload={"HeatRecovery": {"Bypass": {}}})
+
+    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(
+                DucoError,
+                match=re.escape("Expected TempSupTgtZone1 in /config response"),
+            ),
+        ):
+            await client.async_get_bypass_supply_temperature_target(1)
 
 
 async def test_get_bypass_supply_temperature_target_raises_when_unsupported() -> None: