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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.7.0
+Version: 0.8.0
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT
@@ -170,6 +170,8 @@ For local function probes without activating the environment first:
 ```bash
 .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_target --kwargs '{"zone_id": 1}'
 ```
 
 For local real-device validation against your own Duco box, use the opt-in
@@ -193,9 +195,12 @@ development pass, covering:
 - `PATCH /config` with a no-op `TimeZone` write against the current value
 - `GET /info?module=General&submodule=Board`
 - `GET /info?module=General&submodule=Lan`
+- `GET /info?module=Ventilation`
 - `GET /info?module=HeatRecovery`
 - `GET /info/nodes`
 - `GET /info?module=General&submodule=PublicApi`
+- `GET /config?module=HeatRecovery&submodule=Bypass&parameter=TempSupTgtZone1`
+- `PATCH /config?module=HeatRecovery&submodule=Bypass&parameter=TempSupTgtZone1` with a no-op write against the current value
 - `POST /action/nodes/{node}` with a no-op `SetVentilationState`
 
 The repository now also includes opt-in local live tests so the same read and

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

@@ -138,6 +138,8 @@ For local function probes without activating the environment first:
 ```bash
 .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_target --kwargs '{"zone_id": 1}'
 ```
 
 For local real-device validation against your own Duco box, use the opt-in
@@ -161,9 +163,12 @@ development pass, covering:
 - `PATCH /config` with a no-op `TimeZone` write against the current value
 - `GET /info?module=General&submodule=Board`
 - `GET /info?module=General&submodule=Lan`
+- `GET /info?module=Ventilation`
 - `GET /info?module=HeatRecovery`
 - `GET /info/nodes`
 - `GET /info?module=General&submodule=PublicApi`
+- `GET /config?module=HeatRecovery&submodule=Bypass&parameter=TempSupTgtZone1`
+- `PATCH /config?module=HeatRecovery&submodule=Bypass&parameter=TempSupTgtZone1` with a no-op write against the current value
 - `POST /action/nodes/{node}` with a no-op `SetVentilationState`
 
 The repository now also includes opt-in local live tests so the same read and

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

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

{python_duco_connectivity-0.7.0 → python_duco_connectivity-0.8.0}/src/duco_connectivity/__init__.py

@@ -25,6 +25,7 @@ from .models import (
     ApiInfo,
     BoardInfo,
     BoardName,
+    BypassSupplyTemperatureTarget,
     Config,
     ConfigAutoRebootComm,
     ConfigGeneral,
@@ -111,6 +112,7 @@ from .models import (
     VentilationFlowLevelTarget,
     VentilationMode,
     VentilationState,
+    VentilationTemperatureInfo,
     VentilationTimeEnd,
     VentilationTimeRemaining,
     ZoneModuleSelector,
@@ -136,6 +138,7 @@ __all__ = [
     "ApiInfo",
     "BoardInfo",
     "BoardName",
+    "BypassSupplyTemperatureTarget",
     "Config",
     "ConfigAutoRebootComm",
     "ConfigGeneral",
@@ -228,6 +231,7 @@ __all__ = [
     "VentilationFlowLevelTarget",
     "VentilationMode",
     "VentilationState",
+    "VentilationTemperatureInfo",
     "VentilationTimeEnd",
     "VentilationTimeRemaining",
     "ZoneModuleSelector",

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

@@ -2,8 +2,10 @@
 
 import json
 import logging
+import math
 import sys
 from dataclasses import fields, is_dataclass
+from decimal import Decimal, InvalidOperation
 from types import FrameType
 from typing import Any, Literal, cast
 from urllib.parse import urlsplit
@@ -26,6 +28,7 @@ from .models import (
     ApiEndpoint,
     ApiInfo,
     BoardInfo,
+    BypassSupplyTemperatureTarget,
     Config,
     ConfigAutoRebootComm,
     ConfigGeneral,
@@ -81,6 +84,7 @@ from .models import (
     PatchConfigZoneStruct,
     VentilationMode,
     VentilationState,
+    VentilationTemperatureInfo,
     ZoneModuleSelector,
     _PatchPayloadModel,
 )
@@ -306,6 +310,78 @@ class DucoClient:
 
         return raw_value
 
+    @staticmethod
+    def _validate_bypass_zone_id(zone_id: int) -> str:
+        """Return the API parameter name for a supported bypass target zone."""
+        if type(zone_id) is not int or not 1 <= zone_id <= 8:
+            msg = "zone_id must be an integer between 1 and 8"
+            raise ValueError(msg)
+        return f"TempSupTgtZone{zone_id}"
+
+    @staticmethod
+    def _decicelsius_to_celsius(value: int) -> float:
+        """Convert Duco decicelsius values to Celsius floats."""
+        return value / 10.0
+
+    @classmethod
+    def _celsius_to_decicelsius(cls, value: float, *, path: str) -> int:
+        """Convert a Celsius float to the Duco decicelsius integer representation."""
+        if type(value) not in (int, float):
+            msg = f"{path} must be an int or float, got {type(value).__name__}"
+            raise ValueError(msg)
+
+        numeric_value = float(value)
+        if not math.isfinite(numeric_value):
+            msg = f"{path} must be a finite temperature value"
+            raise ValueError(msg)
+
+        try:
+            scaled = Decimal(str(value)) * 10
+        except InvalidOperation as err:
+            msg = f"{path} must be representable as a decimal temperature"
+            raise ValueError(msg) from err
+
+        if scaled != scaled.to_integral_value():
+            msg = f"{path} must be representable in 0.1°C increments"
+            raise ValueError(msg)
+
+        return int(scaled)
+
+    @classmethod
+    def _build_bypass_supply_temperature_target(
+        cls,
+        zone_id: int,
+        value: ConfigValue,
+    ) -> BypassSupplyTemperatureTarget:
+        """Convert a raw config value into a Celsius convenience model."""
+        return BypassSupplyTemperatureTarget(
+            zone_id=zone_id,
+            value=cls._decicelsius_to_celsius(value.value),
+            minimum=None if value.minimum is None else cls._decicelsius_to_celsius(value.minimum),
+            increment=None
+            if value.increment is None
+            else cls._decicelsius_to_celsius(value.increment),
+            maximum=None if value.maximum is None else cls._decicelsius_to_celsius(value.maximum),
+            raw_payload=cls._preserve_raw_payload(value.raw_payload),
+        )
+
+    @classmethod
+    def _extract_bypass_supply_temperature_target(
+        cls,
+        config: Config,
+        zone_id: int,
+    ) -> BypassSupplyTemperatureTarget | None:
+        """Read a single bypass supply target from a typed config response."""
+        heat_recovery = config.heat_recovery
+        if heat_recovery is None or heat_recovery.bypass is None:
+            return None
+
+        raw_value = getattr(heat_recovery.bypass, f"temp_sup_tgt_zone_{zone_id}")
+        if raw_value is None:
+            return None
+
+        return cls._build_bypass_supply_temperature_target(zone_id, raw_value)
+
     @staticmethod
     def _read_scalar_value(payload: dict[str, Any], key: str) -> Any:
         raw_value = payload[key]
@@ -2112,7 +2188,23 @@ class DucoClient:
 
     async def async_get_time_filter_remaining(self) -> int | None:
         """Return the remaining heat recovery filter time when the box reports it."""
-        payload = await self.async_get_info(module=InfoModuleSelector.HEAT_RECOVERY)
+        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
+            raise
+
         if not isinstance(payload, dict):
             msg = (
                 "Expected object payload from /info?module=HeatRecovery, got "
@@ -2143,6 +2235,82 @@ 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)
+
+        if not isinstance(payload, dict):
+            msg = (
+                "Expected object payload from /info?module=Ventilation, got "
+                f"{type(payload).__name__}"
+            )
+            raise DucoError(msg)
+
+        ventilation = payload.get("Ventilation")
+        if ventilation is None:
+            return VentilationTemperatureInfo()
+        if not isinstance(ventilation, dict):
+            msg = "Expected object payload at Ventilation in /info?module=Ventilation response"
+            raise DucoError(msg)
+
+        sensor = ventilation.get("Sensor")
+        if sensor is None:
+            return VentilationTemperatureInfo(raw_payload=self._preserve_raw_payload(ventilation))
+        if not isinstance(sensor, dict):
+            msg = (
+                "Expected object payload at Ventilation.Sensor in /info?module=Ventilation response"
+            )
+            raise DucoError(msg)
+
+        temp_oda = self._read_optional_wrapped_int(sensor, "TempOda", path="Ventilation.Sensor")
+        temp_sup = self._read_optional_wrapped_int(sensor, "TempSup", path="Ventilation.Sensor")
+        temp_eta = self._read_optional_wrapped_int(sensor, "TempEta", path="Ventilation.Sensor")
+        temp_eha = self._read_optional_wrapped_int(sensor, "TempEha", path="Ventilation.Sensor")
+
+        return VentilationTemperatureInfo(
+            temp_oda=None if temp_oda is None else self._decicelsius_to_celsius(temp_oda),
+            temp_sup=None if temp_sup is None else self._decicelsius_to_celsius(temp_sup),
+            temp_eta=None if temp_eta is None else self._decicelsius_to_celsius(temp_eta),
+            temp_eha=None if temp_eha is None else self._decicelsius_to_celsius(temp_eha),
+            raw_payload=self._preserve_raw_payload(sensor),
+        )
+
+    async def async_get_bypass_supply_temperature_target(
+        self,
+        zone_id: int,
+    ) -> 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,
+        )
+        return self._extract_bypass_supply_temperature_target(config, zone_id)
+
+    async def async_set_bypass_supply_temperature_target(
+        self,
+        zone_id: int,
+        temperature: float,
+    ) -> BypassSupplyTemperatureTarget:
+        """Set a bypass supply target through `/config` using Celsius input."""
+        parameter = self._validate_bypass_zone_id(zone_id)
+        raw_value = self._celsius_to_decicelsius(
+            temperature,
+            path=f"bypass_supply_temperature_target[{zone_id}]",
+        )
+        response = await self.async_set_config(
+            {"HeatRecovery": {"Bypass": {parameter: PatchConfigValue(value=raw_value)}}},
+            module=ConfigModuleSelector.HEAT_RECOVERY,
+            submodule=ConfigHeatRecoverySubmoduleSelector.BYPASS,
+            parameter=parameter,
+        )
+        target = self._extract_bypass_supply_temperature_target(response, zone_id)
+        if target is None:
+            msg = f"Expected {parameter} in /config response after bypass target write"
+            raise DucoError(msg)
+        return target
+
     async def async_get_write_req_remaining(self) -> int:
         """Backward-compatible alias for the old write budget method name."""
         caller = _compat_caller()

{python_duco_connectivity-0.7.0 → python_duco_connectivity-0.8.0}/src/duco_connectivity/models.py

@@ -923,6 +923,29 @@ class LanInfo:
         object.__setattr__(self, "raw_payload", {} if raw_payload is None else raw_payload)
 
 
+@dataclass(frozen=True, slots=True)
+class VentilationTemperatureInfo:
+    """Ventilation temperature values reported by `/info?module=Ventilation`."""
+
+    temp_oda: float | None = None
+    temp_sup: float | None = None
+    temp_eta: float | None = None
+    temp_eha: float | None = None
+    raw_payload: dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+
+@dataclass(frozen=True, slots=True)
+class BypassSupplyTemperatureTarget:
+    """Bypass supply temperature target values exposed through `/config`."""
+
+    zone_id: int
+    value: float
+    minimum: float | None = None
+    increment: float | None = None
+    maximum: float | None = None
+    raw_payload: dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+
 @dataclass(frozen=True, slots=True)
 class ConfigValue:
     """Integer config value reported by the local Duco API."""

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.7.0
+Version: 0.8.0
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT
@@ -170,6 +170,8 @@ For local function probes without activating the environment first:
 ```bash
 .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_target --kwargs '{"zone_id": 1}'
 ```
 
 For local real-device validation against your own Duco box, use the opt-in
@@ -193,9 +195,12 @@ development pass, covering:
 - `PATCH /config` with a no-op `TimeZone` write against the current value
 - `GET /info?module=General&submodule=Board`
 - `GET /info?module=General&submodule=Lan`
+- `GET /info?module=Ventilation`
 - `GET /info?module=HeatRecovery`
 - `GET /info/nodes`
 - `GET /info?module=General&submodule=PublicApi`
+- `GET /config?module=HeatRecovery&submodule=Bypass&parameter=TempSupTgtZone1`
+- `PATCH /config?module=HeatRecovery&submodule=Bypass&parameter=TempSupTgtZone1` with a no-op write against the current value
 - `POST /action/nodes/{node}` with a no-op `SetVentilationState`
 
 The repository now also includes opt-in local live tests so the same read and

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

@@ -16,6 +16,7 @@ from duco_connectivity import (
     ActionResultStatus,
     ActionValueType,
     BoardName,
+    BypassSupplyTemperatureTarget,
     Config,
     ConfigAutoRebootComm,
     ConfigGeneral,
@@ -96,6 +97,7 @@ from duco_connectivity import (
     VentilationFlowLevelTarget,
     VentilationMode,
     VentilationState,
+    VentilationTemperatureInfo,
     VentilationTimeEnd,
     VentilationTimeRemaining,
     ZoneModuleSelector,
@@ -3653,6 +3655,183 @@ async def test_get_nodes_known_spec_node_types_are_parsed(node_type: str) -> Non
     assert nodes[0].general.node_type == NodeType(node_type)
 
 
+async def test_get_ventilation_temperature_info_is_parsed(
+    ventilation_info_data: dict[str, object],
+) -> None:
+    """Ventilation temperatures should be converted from decicelsius to Celsius."""
+    mock_response = _response(json_payload=ventilation_info_data)
+
+    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 == VentilationTemperatureInfo(
+        temp_oda=17.5,
+        temp_sup=18.0,
+        temp_eta=21.5,
+        temp_eha=22.5,
+    )
+    assert payload.raw_payload is ventilation_info_data["Ventilation"]["Sensor"]
+
+
+async def test_get_ventilation_temperature_info_returns_empty_model_when_sensor_missing() -> None:
+    """Missing ventilation sensors should return an empty typed model."""
+    mock_response = _response(json_payload={"Ventilation": {}})
+
+    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 == VentilationTemperatureInfo()
+    assert payload.raw_payload == {}
+
+
+@pytest.mark.parametrize(
+    ("payload", "message"),
+    [
+        pytest.param(
+            [],
+            "Expected object payload from /info?module=Ventilation, got list",
+            id="root_not_object",
+        ),
+        pytest.param(
+            {"Ventilation": []},
+            "Expected object payload at Ventilation in /info?module=Ventilation response",
+            id="ventilation_not_object",
+        ),
+        pytest.param(
+            {"Ventilation": {"Sensor": []}},
+            "Expected object payload at Ventilation.Sensor in /info?module=Ventilation response",
+            id="sensor_not_object",
+        ),
+        pytest.param(
+            {"Ventilation": {"Sensor": {"TempOda": 175}}},
+            "Expected wrapped Val object for Ventilation.Sensor.TempOda, got int",
+            id="leaf_not_object",
+        ),
+        pytest.param(
+            {"Ventilation": {"Sensor": {"TempOda": {"Val": "175"}}}},
+            "Expected integer value for Ventilation.Sensor.TempOda, got str",
+            id="leaf_non_int_val",
+        ),
+    ],
+)
+async def test_get_ventilation_temperature_info_rejects_malformed_payloads(
+    payload: object,
+    message: str,
+) -> None:
+    """Malformed ventilation temperature payloads should raise DucoError."""
+    mock_response = _response(json_payload=payload)
+
+    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(message)),
+        ):
+            await client.async_get_ventilation_temperature_info()
+
+
+async def test_get_bypass_supply_temperature_target_returns_converted_values(
+    config_data: dict[str, object],
+) -> None:
+    """Bypass target helpers should convert raw config metadata to 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):
+            payload = await client.async_get_bypass_supply_temperature_target(1)
+
+    assert payload == BypassSupplyTemperatureTarget(
+        zone_id=1,
+        value=18.0,
+        minimum=12.0,
+        increment=0.5,
+        maximum=22.0,
+    )
+    assert request_mock.call_args.kwargs["params"] == {
+        "module": "HeatRecovery",
+        "submodule": "Bypass",
+        "parameter": "TempSupTgtZone1",
+    }
+
+
+async def test_get_bypass_supply_temperature_target_returns_none_when_not_reported() -> None:
+    """Missing bypass targets should return None instead of failing."""
+    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)
+
+    assert payload is None
+
+
+@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."""
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with pytest.raises(ValueError, match="zone_id must be an integer between 1 and 8"):
+            await client.async_get_bypass_supply_temperature_target(cast(Any, zone_id))
+
+        with pytest.raises(ValueError, match="zone_id must be an integer between 1 and 8"):
+            await client.async_set_bypass_supply_temperature_target(cast(Any, zone_id), 18.0)
+
+
+async def test_set_bypass_supply_temperature_target_serializes_decicelsius(
+    config_data: dict[str, object],
+) -> None:
+    """Bypass target helpers should serialize Celsius writes as raw decicelsius values."""
+    mock_response = _response(json_payload=config_data)
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        request = MagicMock(return_value=_request_context(mock_response))
+        with patch.object(session, "request", request):
+            payload = await client.async_set_bypass_supply_temperature_target(2, 18.5)
+
+    assert payload == BypassSupplyTemperatureTarget(
+        zone_id=2,
+        value=18.5,
+        minimum=12.0,
+        increment=0.5,
+        maximum=22.0,
+    )
+    _, kwargs = request.call_args
+    assert kwargs["params"] == {
+        "module": "HeatRecovery",
+        "submodule": "Bypass",
+        "parameter": "TempSupTgtZone2",
+    }
+    assert kwargs["data"] == b'{"HeatRecovery":{"Bypass":{"TempSupTgtZone2":{"Val":185}}}}'
+    assert kwargs["headers"] == {"Content-Type": "application/json"}
+
+
+@pytest.mark.parametrize(
+    ("value", "message"),
+    [
+        pytest.param(18.34, "must be representable in 0.1°C increments", id="not_decicelsius"),
+        pytest.param(float("inf"), "must be a finite temperature value", id="not_finite"),
+        pytest.param(True, "must be an int or float, got bool", id="bool"),
+    ],
+)
+async def test_set_bypass_supply_temperature_target_rejects_invalid_temperatures(
+    value: object,
+    message: str,
+) -> None:
+    """Invalid convenience write values should fail before a request is sent."""
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with pytest.raises(ValueError, match=re.escape(message)):
+            await client.async_set_bypass_supply_temperature_target(1, cast(Any, value))
+
+
 async def test_get_write_requests_remaining_is_parsed() -> None:
     """Test parsing of the remaining write budget."""
     payload: dict[str, object] = {"General": {"PublicApi": {"WriteReqCntRemain": {"Val": 197}}}}
@@ -3692,6 +3871,21 @@ async def test_get_time_filter_remaining_returns_none_when_not_reported() -> Non
     assert remaining is None
 
 
+async def test_get_time_filter_remaining_returns_none_when_module_unsupported() -> None:
+    """Heat recovery filter time should stay optional for boxes without that module."""
+    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)):
+            remaining = await client.async_get_time_filter_remaining()
+
+    assert remaining is None
+
+
 @pytest.mark.parametrize(
     ("payload", "message"),
     [

{python_duco_connectivity-0.7.0 → python_duco_connectivity-0.8.0}/tests/test_models.py

@@ -17,6 +17,7 @@ from duco_connectivity import (
     ApiInfo,
     BoardInfo,
     BoardName,
+    BypassSupplyTemperatureTarget,
     Config,
     ConfigAutoRebootComm,
     ConfigGeneral,
@@ -95,6 +96,7 @@ from duco_connectivity import (
     VentilationFlowLevelTarget,
     VentilationMode,
     VentilationState,
+    VentilationTemperatureInfo,
     VentilationTimeEnd,
     VentilationTimeRemaining,
     ZoneModuleSelector,
@@ -659,6 +661,33 @@ def test_patch_config_models_build_typed_write_families() -> None:
     assert node_patch.name == PatchConfigNodeValue(value="Kitchen valve")
 
 
+def test_temperature_convenience_models_default_and_preserve_values() -> None:
+    """Temperature convenience models should keep converted Celsius values explicit."""
+    ventilation = VentilationTemperatureInfo(
+        temp_oda=17.5,
+        temp_sup=18.0,
+        temp_eta=21.5,
+        temp_eha=22.5,
+    )
+    target = BypassSupplyTemperatureTarget(
+        zone_id=2,
+        value=18.5,
+        minimum=12.0,
+        increment=0.5,
+        maximum=22.0,
+    )
+
+    assert ventilation.temp_oda == 17.5
+    assert ventilation.temp_sup == 18.0
+    assert ventilation.temp_eta == 21.5
+    assert ventilation.temp_eha == 22.5
+    assert target.zone_id == 2
+    assert target.value == 18.5
+    assert target.minimum == 12.0
+    assert target.increment == 0.5
+    assert target.maximum == 22.0
+
+
 def test_config_group_struct_defaults() -> None:
     """ConfigGroupStruct should preserve an empty raw payload by default."""
     group = ConfigGroupStruct()