PyPlumIO 0.5.48__tar.gz → 0.5.50__tar.gz

{pyplumio-0.5.48 → pyplumio-0.5.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.48
+Version: 0.5.50
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License

{pyplumio-0.5.48 → pyplumio-0.5.50}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.48
+Version: 0.5.50
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License

{pyplumio-0.5.48 → pyplumio-0.5.50}/PyPlumIO.egg-info/SOURCES.txt

@@ -133,9 +133,11 @@ tests/parameters/test_init.py
 tests/parameters/test_mixers.py
 tests/parameters/test_thermostats.py
 tests/parameters/custom/__init__.py
+tests/parameters/custom/test_ecomax_860d3_hb.py
 tests/parameters/custom/test_init.py
 tests/testdata/messages/regulator_data.json
 tests/testdata/messages/sensor_data.json
+tests/testdata/parameters/ecomax_860d3_hb.json
 tests/testdata/requests/alerts.json
 tests/testdata/requests/ecomax_control.json
 tests/testdata/requests/ecomax_parameters.json

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.48'
-__version_tuple__ = version_tuple = (0, 5, 48)
+__version__ = version = '0.5.50'
+__version_tuple__ = version_tuple = (0, 5, 50)

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/const.py

@@ -184,6 +184,7 @@ class FrameType(IntEnum):
     REQUEST_SET_MIXER_PARAMETER = 52
     REQUEST_SCHEDULES = 54
     REQUEST_SET_SCHEDULE = 55
+    REQUEST_ECOMAX_PARAMETER_CHANGES = 56
     REQUEST_UID = 57
     REQUEST_PASSWORD = 58
     REQUEST_ECOMAX_CONTROL = 59
@@ -203,6 +204,7 @@ class FrameType(IntEnum):
     RESPONSE_ECOMAX_CONTROL = 187
     RESPONSE_ALERTS = 189
     RESPONSE_PROGRAM_VERSION = 192
+    RESPONSE_ECOMAX_PARAMETER_CHANGES = 212
     RESPONSE_REGULATOR_DATA_SCHEMA = 213
     RESPONSE_THERMOSTAT_PARAMETERS = 220
     RESPONSE_SET_THERMOSTAT_PARAMETER = 221

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/devices/__init__.py

@@ -72,7 +72,7 @@ class Device(ABC, EventManager):
         :param name: Name of the parameter
         :type name: str
         :param value: New value for the parameter
-        :type value: int | float | bool | Literal["off", "on"]
+        :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
             times, defaults to 5
         :type retries: int, optional
@@ -104,7 +104,7 @@ class Device(ABC, EventManager):
         :param name: Name of the parameter
         :type name: str
         :param value: New value for the parameter
-        :type value: int | float | bool | Literal["off", "on"]
+        :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
             times, defaults to 5
         :type retries: int, optional
@@ -145,21 +145,26 @@ class PhysicalDevice(Device, ABC):
     @event_listener(filter=on_change)
     async def on_event_frame_versions(self, versions: dict[int, int]) -> None:
         """Check frame versions and update outdated frames."""
-        _LOGGER.info("Received frame version table")
+        _LOGGER.debug("Received frame version table")
         for frame_type, version in versions.items():
             if (
                 is_known_frame_type(frame_type)
                 and self.supports_frame_type(frame_type)
                 and not self.has_frame_version(frame_type, version)
             ):
-                await self._request_frame_version(frame_type, version)
+                request_frame_type = (
+                    FrameType.REQUEST_ECOMAX_PARAMETERS
+                    if frame_type == FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES
+                    else frame_type
+                )
+                await self._request_frame_version(request_frame_type, version)
                 self._frame_versions[frame_type] = version
 
     async def _request_frame_version(
         self, frame_type: FrameType | int, version: int
     ) -> None:
         """Request frame version from the device."""
-        _LOGGER.info("Updating frame %s to version %i", repr(frame_type), version)
+        _LOGGER.debug("Updating frame %s to version %i", repr(frame_type), version)
         request = await Request.create(frame_type, recipient=self.address)
         self.queue.put_nowait(request)
 

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/devices/ecomax.py

@@ -234,7 +234,7 @@ class EcoMAX(PhysicalDevice):
     @event_listener
     async def on_event_setup(self, setup: bool) -> None:
         """Request frames required to set up an ecoMAX entry."""
-        _LOGGER.info("Setting up device entry")
+        _LOGGER.debug("Setting up device entry")
         await self.wait_for(ATTR_SENSORS)
         results = await asyncio.gather(
             *(
@@ -251,14 +251,14 @@ class EcoMAX(PhysicalDevice):
         if errors:
             self.dispatch_nowait(ATTR_FRAME_ERRORS, errors)
 
-        _LOGGER.info("Device entry setup done")
+        _LOGGER.debug("Device entry setup done")
 
     @event_listener
     async def on_event_ecomax_parameters(
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update ecoMAX parameters and dispatch the events."""
-        _LOGGER.info("Received device parameters")
+        _LOGGER.debug("Received device parameters")
         product_info: ProductInfo = await self.get(ATTR_PRODUCT)
         parameter_types = await get_ecomax_parameter_types(product_info)
 
@@ -307,7 +307,7 @@ class EcoMAX(PhysicalDevice):
         parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
     ) -> bool:
         """Handle mixer parameters and dispatch the events."""
-        _LOGGER.info("Received mixer parameters")
+        _LOGGER.debug("Received mixer parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -324,7 +324,7 @@ class EcoMAX(PhysicalDevice):
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Update mixer sensors and dispatch the events."""
-        _LOGGER.info("Received mixer sensors")
+        _LOGGER.debug("Received mixer sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -364,7 +364,7 @@ class EcoMAX(PhysicalDevice):
     @event_listener
     async def on_event_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update ecoMAX sensors and dispatch the events."""
-        _LOGGER.info("Received device sensors")
+        _LOGGER.debug("Received device sensors")
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -376,7 +376,7 @@ class EcoMAX(PhysicalDevice):
         parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
     ) -> bool:
         """Handle thermostat parameters and dispatch the events."""
-        _LOGGER.info("Received thermostat parameters")
+        _LOGGER.debug("Received thermostat parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -407,7 +407,7 @@ class EcoMAX(PhysicalDevice):
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Update thermostat sensors and dispatch the events."""
-        _LOGGER.info("Received thermostat sensors")
+        _LOGGER.debug("Received thermostat sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -427,7 +427,7 @@ class EcoMAX(PhysicalDevice):
         self, schedules: list[tuple[int, list[list[bool]]]]
     ) -> dict[str, Schedule]:
         """Update schedules."""
-        _LOGGER.info("Received device schedules")
+        _LOGGER.debug("Received device schedules")
         return {
             SCHEDULES[index]: Schedule(
                 name=SCHEDULES[index],

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/devices/mixer.py

@@ -29,7 +29,7 @@ class Mixer(VirtualDevice):
     @event_listener
     async def on_event_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update mixer sensors and dispatch the events."""
-        _LOGGER.info("Received mixer %i sensors", self.index)
+        _LOGGER.debug("Received mixer %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -40,7 +40,7 @@ class Mixer(VirtualDevice):
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update mixer parameters and dispatch the events."""
-        _LOGGER.info("Received mixer %i parameters", self.index)
+        _LOGGER.debug("Received mixer %i parameters", self.index)
         product_info: ProductInfo = await self.parent.get(ATTR_PRODUCT)
         parameter_types = get_mixer_parameter_types(product_info)
 

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/devices/thermostat.py

@@ -28,7 +28,7 @@ class Thermostat(VirtualDevice):
     @event_listener
     async def on_event_thermostat_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update thermostat sensors and dispatch the events."""
-        _LOGGER.info("Received thermostat %i sensors", self.index)
+        _LOGGER.debug("Received thermostat %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -39,7 +39,7 @@ class Thermostat(VirtualDevice):
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update thermostat parameters and dispatch the events."""
-        _LOGGER.info("Received thermostat %i parameters", self.index)
+        _LOGGER.debug("Received thermostat %i parameters", self.index)
         parameter_types = get_thermostat_parameter_types()
 
         def _thermostat_parameter_events() -> Generator[Coroutine]:

pyplumio-0.5.50/pyplumio/parameters/custom/ecomax_860d3_hb.py

@@ -0,0 +1,80 @@
+"""Contains patch for ecoMAX 860D3-HB."""
+
+from pyplumio.const import UnitOfMeasurement
+from pyplumio.parameters.custom import CustomParameter, CustomParameters, Signature
+from pyplumio.parameters.ecomax import EcomaxNumberDescription, EcomaxSwitchDescription
+
+
+class EcoMAX860D3HB(CustomParameters):
+    """Replacements for ecoMAX 860D3-HB."""
+
+    __slots__ = ()
+
+    signature = Signature(model="ecoMAX 860D3-HB", id=48)
+
+    replacements = (
+        # Summer mode
+        CustomParameter(
+            original="summer_mode_disable_temp",
+            replacement=EcomaxNumberDescription(name="__unknown_parameter_1"),
+        ),
+        CustomParameter(
+            original="water_heater_target_temp",
+            replacement=EcomaxNumberDescription(name="summer_mode"),
+        ),
+        CustomParameter(
+            original="min_water_heater_target_temp",
+            replacement=EcomaxNumberDescription(
+                name="summer_mode_enable_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="max_water_heater_target_temp",
+            replacement=EcomaxNumberDescription(
+                name="summer_mode_disable_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        # Water heater
+        CustomParameter(
+            original="disable_pump_on_thermostat",
+            replacement=EcomaxNumberDescription(
+                name="water_heater_target_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="boiler_alert_temp",
+            replacement=EcomaxNumberDescription(
+                name="min_water_heater_target_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="max_feeder_temp",
+            replacement=EcomaxNumberDescription(
+                name="max_water_heater_target_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="water_heater_work_mode",
+            replacement=EcomaxNumberDescription(name="water_heater_feeding_extension"),
+        ),
+        CustomParameter(
+            original="external_boiler_temp",
+            replacement=EcomaxNumberDescription(name="water_heater_work_mode"),
+        ),
+        CustomParameter(
+            original="alert_notify",
+            replacement=EcomaxNumberDescription(
+                name="water_heater_hysteresis",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="pump_hysteresis",
+            replacement=EcomaxSwitchDescription(name="water_heater_disinfection"),
+        ),
+    )

{pyplumio-0.5.48 → pyplumio-0.5.50}/pyplumio/protocol.py

@@ -230,20 +230,17 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     @acache
     async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
         """Return the device entry."""
-
-        @acache
-        async def _setup_device_entry(device_type: DeviceType) -> PhysicalDevice:
-            """Set up the device entry."""
-            device = await PhysicalDevice.create(
-                device_type, queue=self._queues.write, network=self._network
-            )
-            device.dispatch_nowait(ATTR_CONNECTED, True)
-            device.dispatch_nowait(ATTR_SETUP, True)
-            self.dispatch_nowait(device_type.name.lower(), device)
-            return device
-
         async with self._entry_lock:
-            return await _setup_device_entry(device_type)
+            name = device_type.name.lower()
+            if name not in self.data:
+                device = await PhysicalDevice.create(
+                    device_type, queue=self._queues.write, network=self._network
+                )
+                device.dispatch_nowait(ATTR_CONNECTED, True)
+                device.dispatch_nowait(ATTR_SETUP, True)
+                await self.dispatch(device_type.name.lower(), device)
+
+        return self.data[name]
 
 
 __all__ = ["Protocol", "DummyProtocol", "AsyncProtocol"]

{pyplumio-0.5.48 → pyplumio-0.5.50}/tests/conftest.py

@@ -8,6 +8,7 @@ import functools
 import importlib
 import inspect
 import json
+from math import isclose
 import os
 import pathlib
 from typing import Any, Final, TypeVar
@@ -16,8 +17,9 @@ from unittest.mock import patch
 from freezegun import freeze_time
 import pytest
 
-from pyplumio.const import ProductType
+from pyplumio.const import ProductType, State
 from pyplumio.devices.ecomax import EcoMAX
+from pyplumio.parameters import NumericType
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.structures.product_info import ATTR_PRODUCT, ProductInfo
 
@@ -34,7 +36,7 @@ def _create_class_instance(module_name: str, class_name: str, **kwargs):
     return getattr(importlib.import_module(module_name), class_name)(**kwargs)
 
 
-def try_int(key: Any) -> Any:
+def _try_int(key: Any) -> Any:
     """Try to convert key to integer or return key unchanged on error."""
     try:
         return int(key)
@@ -55,7 +57,7 @@ def _decode_hinted_objects(d: Any) -> Any:
     if "__tuple__" in d:
         return tuple(d["items"])
 
-    return {try_int(k): v for k, v in d.items()}
+    return {_try_int(k): v for k, v in d.items()}
 
 
 def load_json_test_data(path: str) -> Any:
@@ -83,9 +85,16 @@ def _bypass_pytest_argument_inspection(
     return wrapper
 
 
-def json_test_data(json_path: str, selector: str | None = None, dataset: int = 0):
+def json_test_data(
+    json_path: str,
+    selector: str | None = None,
+    dataset: int = 0,
+    name: str | None = None,
+):
     """Pytest decorator to inject JSON test data as a test argument."""
-    name = json_path.split("/")[-1].split("\\")[-1].rsplit(".", 1)[0]
+    if not name:
+        name = json_path.split("/")[-1].split("\\")[-1].rsplit(".", 1)[0]
+
     if selector:
         name += f"_{selector}"
 
@@ -104,10 +113,17 @@ def json_test_data(json_path: str, selector: str | None = None, dataset: int = 0
 
 
 def class_from_json(
-    cls: type, json_path: str, /, dataset: int = 0, arguments: Sequence | None = None
+    cls: type,
+    json_path: str,
+    /,
+    dataset: int = 0,
+    arguments: Sequence | None = None,
+    name: str | None = None,
 ):
     """Pytest decorator to inject JSON test data as a test argument."""
-    name = json_path.split("/")[-1].split("\\")[-1].rsplit(".", 1)[0]
+    if not name:
+        name = json_path.split("/")[-1].split("\\")[-1].rsplit(".", 1)[0]
+
     init_args = arguments if arguments else ()
 
     def decorator(test_func):
@@ -124,6 +140,16 @@ def class_from_json(
     return decorator
 
 
+def equal_parameter_value(
+    a: NumericType | State | None, b: NumericType | State | None
+) -> bool:
+    """Compare the parameter values."""
+    if isinstance(a, float) and isinstance(b, float):
+        return isclose(a, b, rel_tol=DEFAULT_TOLERANCE)
+    else:
+        return True if a == b else False
+
+
 @pytest.fixture(autouse=True)
 def skip_asyncio_sleep():
     """Skip an asyncio sleep calls."""
@@ -151,3 +177,12 @@ def fixture_frozen_time():
     """Get frozen time."""
     with freeze_time("2012-12-12 12:00:00") as frozen_time:
         yield frozen_time
+
+
+__all__ = [
+    "class_from_json",
+    "equal_parameter_value",
+    "json_test_data",
+    "load_json_parameters",
+    "load_json_test_data",
+]

{pyplumio-0.5.48 → pyplumio-0.5.50}/tests/devices/test_ecomax.py

@@ -2,8 +2,7 @@
 
 from datetime import timedelta
 import logging
-from math import isclose
-from typing import Any, Literal, cast
+from typing import Any, cast
 from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
@@ -26,6 +25,7 @@ from pyplumio.const import (
     DeviceState,
     DeviceType,
     FrameType,
+    State,
     UnitOfMeasurement,
 )
 from pyplumio.devices.ecomax import (
@@ -43,6 +43,7 @@ from pyplumio.frames.messages import SensorDataMessage
 from pyplumio.frames.requests import (
     AlertsRequest,
     EcomaxControlRequest,
+    EcomaxParametersRequest,
     SetEcomaxParameterRequest,
     SetScheduleRequest,
     SetThermostatParameterRequest,
@@ -81,7 +82,12 @@ from pyplumio.structures.thermostat_sensors import (
     ATTR_THERMOSTATS_AVAILABLE,
     ATTR_THERMOSTATS_CONNECTED,
 )
-from tests.conftest import DEFAULT_TOLERANCE, UNDEFINED, class_from_json, json_test_data
+from tests.conftest import (
+    UNDEFINED,
+    class_from_json,
+    equal_parameter_value,
+    json_test_data,
+)
 
 
 @patch("asyncio.Queue.put_nowait")
@@ -99,10 +105,24 @@ async def test_ecomax_handle_frame(
     mock_handle_frame.assert_called_once_with(request)
 
 
+@pytest.mark.parametrize(
+    ("frame_type", "frame_request"),
+    [
+        (FrameType.REQUEST_ALERTS, AlertsRequest(recipient=DeviceType.ECOMAX)),
+        (
+            FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES,
+            EcomaxParametersRequest(recipient=DeviceType.ECOMAX),
+        ),
+    ],
+)
 @patch("asyncio.Queue.put_nowait")
 @class_from_json(SensorDataMessage, "messages/sensor_data.json", arguments=("message",))
 async def test_frame_versions_tracker(
-    mock_put_nowait, ecomax: EcoMAX, sensor_data: SensorDataMessage
+    mock_put_nowait,
+    ecomax: EcoMAX,
+    sensor_data: SensorDataMessage,
+    frame_type: FrameType,
+    frame_request: Request,
 ) -> None:
     """Test frame version tracker."""
 
@@ -111,7 +131,7 @@ async def test_frame_versions_tracker(
         return {ATTR_SENSORS: {ATTR_FRAME_VERSIONS: {frame: version}}}
 
     # Test with frame type that are handled during setup.
-    sensor_data.data = _frame_version_data(FrameType.REQUEST_ALERTS, 1)
+    sensor_data.data = _frame_version_data(frame_type, 1)
     ecomax.data.clear()
     ecomax.handle_frame(sensor_data)
     await ecomax.wait_until_done()
@@ -119,18 +139,16 @@ async def test_frame_versions_tracker(
 
     # Test with same frame type after setup done.
     mock_put_nowait.reset_mock()
-    sensor_data.data = _frame_version_data(FrameType.REQUEST_ALERTS, 2)
+    sensor_data.data = _frame_version_data(frame_type, 2)
     ecomax.data.clear()
     ecomax.data[ATTR_SETUP] = True
     ecomax.handle_frame(sensor_data)
     await ecomax.wait_until_done()
-    mock_put_nowait.assert_called_once_with(AlertsRequest(recipient=DeviceType.ECOMAX))
+    mock_put_nowait.assert_called_once_with(frame_request)
 
 
 @pytest.mark.parametrize("state", [STATE_ON, STATE_OFF])
-async def test_ecomax_control(
-    state: Literal["on", "off"], ecomax: EcoMAX, caplog
-) -> None:
+async def test_ecomax_control(state: State, ecomax: EcoMAX, caplog) -> None:
     """Test ecoMAX control."""
     coro = getattr(ecomax, f"turn_{state}")
     await coro()
@@ -143,9 +161,7 @@ async def test_ecomax_control(
 
 @pytest.mark.parametrize("state", [STATE_ON, STATE_OFF])
 @patch("pyplumio.devices.ecomax.EcoMAX.create_task")
-def test_ecomax_control_nowait(
-    mock_create_task, ecomax: EcoMAX, state: Literal["on", "off"]
-) -> None:
+def test_ecomax_control_nowait(mock_create_task, ecomax: EcoMAX, state: State) -> None:
     """Test ecoMAX control without waiting for result."""
     func = getattr(ecomax, f"turn_{state}_nowait")
     with patch(
@@ -237,9 +253,9 @@ async def test_ecomax_parameters_event_listener(
     # Test parameter with the step (heating_heat_curve)
     fuel_calorific_value = ecomax.get_nowait("fuel_calorific_value")
     assert isinstance(fuel_calorific_value, EcomaxNumber)
-    assert isclose(fuel_calorific_value.value, 4.6, rel_tol=DEFAULT_TOLERANCE)
-    assert isclose(fuel_calorific_value.min_value, 0.1, rel_tol=DEFAULT_TOLERANCE)
-    assert isclose(fuel_calorific_value.max_value, 25.0, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(fuel_calorific_value.value, 4.6)
+    assert equal_parameter_value(fuel_calorific_value.min_value, 0.1)
+    assert equal_parameter_value(fuel_calorific_value.max_value, 25.0)
 
     # Test setting parameter with the step.
     await fuel_calorific_value.set(2.5)
@@ -250,9 +266,9 @@ async def test_ecomax_parameters_event_listener(
     # Test parameter with the offset (heating_heat_curve_shift)
     heating_heat_curve_shift = ecomax.get_nowait("heating_curve_shift")
     assert isinstance(heating_heat_curve_shift, EcomaxNumber)
-    assert isclose(heating_heat_curve_shift.value, 0.0, rel_tol=DEFAULT_TOLERANCE)
-    assert isclose(heating_heat_curve_shift.min_value, -20.0, rel_tol=DEFAULT_TOLERANCE)
-    assert isclose(heating_heat_curve_shift.max_value, 20.0, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(heating_heat_curve_shift.value, 0.0)
+    assert equal_parameter_value(heating_heat_curve_shift.min_value, -20.0)
+    assert equal_parameter_value(heating_heat_curve_shift.max_value, 20.0)
     assert heating_heat_curve_shift.unit_of_measurement == UnitOfMeasurement.CELSIUS
 
     # Test setting the parameter with the offset.
@@ -302,7 +318,7 @@ async def test_fuel_consumption_event_listener(
     ecomax.handle_frame(Response(data={ATTR_FUEL_CONSUMPTION: 3.6}))
     await ecomax.wait_until_done()
     fuel_burned = cast(float, ecomax.get_nowait(ATTR_FUEL_BURNED))
-    assert isclose(fuel_burned, 0.01, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(fuel_burned, 0.01)
 
     # Test with outdated data.
     message = "Skipping outdated fuel consumption"
@@ -310,7 +326,7 @@ async def test_fuel_consumption_event_listener(
     ecomax.handle_frame(Response(data={ATTR_FUEL_CONSUMPTION: 1}))
     await ecomax.wait_until_done()
     fuel_burned = cast(float, ecomax.get_nowait(ATTR_FUEL_BURNED))
-    assert isclose(fuel_burned, 0.01, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(fuel_burned, 0.01)
     assert message in caplog.text
     caplog.clear()
 
@@ -319,7 +335,7 @@ async def test_fuel_consumption_event_listener(
     await ecomax.wait_until_done()
     assert message not in caplog.text
     fuel_burned = cast(float, ecomax.get_nowait(ATTR_FUEL_BURNED))
-    assert isclose(fuel_burned, 0.02, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(fuel_burned, 0.02)
 
 
 @class_from_json(
@@ -376,7 +392,7 @@ async def test_ecomax_sensors_event_listener(
     ecomax.handle_frame(sensor_data)
     await ecomax.wait_until_done()
     heating_target = cast(float, ecomax.get_nowait("heating_target"))
-    assert isclose(heating_target, 41.0, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(heating_target, 41.0)
 
     ecomax_control = ecomax.get_nowait(ATTR_ECOMAX_CONTROL)
     assert isinstance(ecomax_control, EcomaxSwitch)
@@ -447,9 +463,9 @@ async def test_thermostat_profile_event_listener(
     await ecomax.wait_until_done()
     thermostat_profile = ecomax.get_nowait(ATTR_THERMOSTAT_PROFILE)
     assert isinstance(thermostat_profile, EcomaxNumber)
-    assert isclose(thermostat_profile.value, 0.0, rel_tol=DEFAULT_TOLERANCE)
-    assert isclose(thermostat_profile.min_value, 0.0, rel_tol=DEFAULT_TOLERANCE)
-    assert isclose(thermostat_profile.max_value, 5.0, rel_tol=DEFAULT_TOLERANCE)
+    assert equal_parameter_value(thermostat_profile.value, 0.0)
+    assert equal_parameter_value(thermostat_profile.min_value, 0.0)
+    assert equal_parameter_value(thermostat_profile.max_value, 5.0)
     thermostat_profile_request = await thermostat_profile.create_request()
     assert isinstance(thermostat_profile_request, SetThermostatParameterRequest)
     assert thermostat_profile_request.data == {

{pyplumio-0.5.48 → pyplumio-0.5.50}/tests/devices/test_init.py

@@ -102,19 +102,34 @@ def fixture_physical_device() -> PhysicalDevice:
 class TestPhysicalDevice:
     """Contains tests for PhysicalDevice class."""
 
+    @pytest.mark.parametrize(
+        ("frame_type", "requested_frame_type"),
+        [
+            (FrameType.REQUEST_ALERTS, FrameType.REQUEST_ALERTS),
+            (
+                FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES,
+                FrameType.REQUEST_ECOMAX_PARAMETERS,
+            ),
+        ],
+    )
     @patch("pyplumio.frames.Request.create", autospec=True)
     @patch("asyncio.Queue.put_nowait")
     async def test_frame_versions_event_listener(
-        self, mock_put_nowait, mock_request_create, physical_device: PhysicalDevice
+        self,
+        mock_put_nowait,
+        mock_request_create,
+        physical_device: PhysicalDevice,
+        frame_type: FrameType,
+        requested_frame_type: FrameType,
     ) -> None:
         """Test event listener for frame versions."""
-        assert physical_device.has_frame_version(FrameType.REQUEST_ALERTS, 1) is False
-        await physical_device.on_event_frame_versions({FrameType.REQUEST_ALERTS: 1})
+        assert physical_device.has_frame_version(frame_type, 1) is False
+        await physical_device.on_event_frame_versions({frame_type: 1})
         mock_request_create.assert_awaited_once_with(
-            FrameType.REQUEST_ALERTS, recipient=DummyPhysicalDevice.address
+            requested_frame_type, recipient=DummyPhysicalDevice.address
         )
         mock_put_nowait.assert_called_once_with(mock_request_create.return_value)
-        assert physical_device.has_frame_version(FrameType.REQUEST_ALERTS, 1) is True
+        assert physical_device.has_frame_version(frame_type, 1) is True
 
     def test_frame_versions_event_listener_decorator(self) -> None:
         """Test decorator for the frame version event listener."""