PyPlumIO 0.4.0.post1__tar.gz → 0.4.2__tar.gz

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/.vscode/settings.json

@@ -1,7 +1,7 @@
 {
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
-    "python.formatting.provider": "black",
+    "python.formatting.provider": "none",
     "editor.formatOnSave": true,
     "editor.codeActionsOnSave": {
         "source.organizeImports": true
@@ -16,5 +16,8 @@
     "editor.rulers": [
         72,
         88
-    ]
+    ],
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    }
 }

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/PKG-INFO

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

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/PyPlumIO.egg-info/PKG-INFO

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

PyPlumIO-0.4.2/pyplumio/_version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '0.4.2'
+__version_tuple__ = version_tuple = (0, 4, 2)

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/const.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 from enum import IntEnum, unique
 from typing import Final
 
+UNDEFINED: Final = "undefined"
+
 # Binary states.
 STATE_ON: Final = "on"
 STATE_OFF: Final = "off"
@@ -12,6 +14,7 @@ STATE_OFF: Final = "off"
 ATTR_CONNECTED: Final = "connected"
 ATTR_CURRENT_TEMP: Final = "current_temp"
 ATTR_DEVICE_INDEX: Final = "device_index"
+ATTR_FRAME_ERRORS: Final = "frame_errors"
 ATTR_INDEX: Final = "index"
 ATTR_LOADED: Final = "loaded"
 ATTR_OFFSET: Final = "offset"

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/devices/__init__.py

@@ -6,7 +6,7 @@ import logging
 from typing import ClassVar
 
 from pyplumio import util
-from pyplumio.const import ATTR_LOADED, DeviceType, FrameType
+from pyplumio.const import ATTR_FRAME_ERRORS, ATTR_LOADED, DeviceType, FrameType
 from pyplumio.exceptions import ParameterNotFoundError, UnknownDeviceError
 from pyplumio.frames import DataFrameDescription, Frame, Request, get_frame_handler
 from pyplumio.helpers.event_manager import EventManager
@@ -99,22 +99,23 @@ class Addressable(Device):
 
     async def async_setup(self) -> bool:
         """Setup addressable device object."""
-        try:
-            await asyncio.gather(
-                *{
-                    self.create_task(
-                        self.request(description.provides, description.frame_type)
-                    )
-                    for description in self._frame_types
-                },
-                return_exceptions=False,
-            )
-            await self.dispatch(ATTR_LOADED, True)
-            return True
-        except ValueError as e:
-            _LOGGER.error("Request failed: %s", e)
-            await self.dispatch(ATTR_LOADED, False)
-            return False
+        results = await asyncio.gather(
+            *{
+                self.create_task(
+                    self.request(description.provides, description.frame_type)
+                )
+                for description in self._frame_types
+            },
+            return_exceptions=True,
+        )
+
+        errors = [
+            result.args[1] for result in results if isinstance(result, ValueError)
+        ]
+
+        await self.dispatch(ATTR_FRAME_ERRORS, errors)
+        await self.dispatch(ATTR_LOADED, True)
+        return True
 
     async def request(
         self,
@@ -136,7 +137,7 @@ class Addressable(Device):
             except asyncio.TimeoutError:
                 retries -= 1
 
-        raise ValueError(f'could not request "{name}" with "{frame_type.name}"')
+        raise ValueError(f'could not request "{name}"', frame_type)
 
 
 class SubDevice(Device):

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/devices/ecomax.py

@@ -8,6 +8,7 @@ import time
 from typing import ClassVar, Final
 
 from pyplumio.const import (
+    ATTR_FRAME_ERRORS,
     ATTR_PASSWORD,
     ATTR_SENSORS,
     ATTR_STATE,
@@ -140,12 +141,24 @@ class EcoMAX(Addressable):
 
         super().handle_frame(frame)
 
+    def _has_frame_version(self, frame_type: FrameType | int, version: int) -> bool:
+        """Check if device instance has a version of the frame."""
+        return (
+            frame_type in self._frame_versions
+            and self._frame_versions[frame_type] == version
+        )
+
+    def _frame_is_supported(self, frame_type: FrameType | int) -> bool:
+        """Check if frame is supported by the device."""
+        return frame_type not in self.data.get(ATTR_FRAME_ERRORS, [])
+
     async def _update_frame_versions(self, versions: dict[int, int]) -> None:
         """Check versions and fetch outdated frames."""
         for frame_type, version in versions.items():
-            if is_known_frame_type(frame_type) and (
-                frame_type not in self._frame_versions
-                or self._frame_versions[frame_type] != version
+            if (
+                is_known_frame_type(frame_type)
+                and self._frame_is_supported(frame_type)
+                and not self._has_frame_version(frame_type, version)
             ):
                 # We don't have this frame or it's version has changed.
                 request = factory(get_frame_handler(frame_type), recipient=self.address)

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/filters.py

@@ -4,34 +4,70 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import math
 import time
-from typing import Any, Final
+from typing import Any, Final, SupportsFloat, SupportsIndex, overload
 
+from pyplumio.const import UNDEFINED
 from pyplumio.helpers.parameter import Parameter
-from pyplumio.helpers.typing import EventCallbackType
+from pyplumio.helpers.typing import EventCallbackType, SupportsSubtraction
 
 TOLERANCE: Final = 0.1
 
 
-def _significantly_changed(old_value, new_value) -> bool:
+@overload
+def _significantly_changed(old: Parameter, new: Parameter) -> bool:
+    """Check if parameter is significantly changed."""
+
+
+@overload
+def _significantly_changed(
+    old: SupportsFloat | SupportsIndex, new: SupportsFloat | SupportsIndex
+) -> bool:
+    """Check if float value is significantly changed."""
+
+
+def _significantly_changed(old, new) -> bool:
     """Check if value is significantly changed."""
-    if old_value is None or (isinstance(old_value, Parameter) and old_value.is_changed):
+    if old == UNDEFINED:
         return True
 
+    if isinstance(old, Parameter) and old.is_changed:
+        return True
+
+    if isinstance(old, Parameter) and isinstance(new, Parameter):
+        return (
+            old.value != new.value
+            or old.min_value != new.min_value
+            or old.max_value != new.max_value
+        )
+
     try:
-        return not math.isclose(old_value, new_value, abs_tol=TOLERANCE)
+        return not math.isclose(old, new, abs_tol=TOLERANCE)
     except TypeError:
         pass
 
-    return old_value != new_value
+    return old != new
+
+
+@overload
+def _diffence_between(old: list, new: list) -> list:
+    """Return the difference between lists."""
 
 
-def _diffence_between(old_value, new_value):
+@overload
+def _diffence_between(old: SupportsSubtraction, new: SupportsSubtraction) -> list:
+    """Return the difference between lists."""
+
+
+def _diffence_between(old, new):
     """Return the difference between values."""
-    if isinstance(old_value, list) and isinstance(new_value, list):
-        return [x for x in new_value if x not in old_value]
+    if old == UNDEFINED:
+        return None
+
+    if isinstance(old, list) and isinstance(new, list):
+        return [x for x in new if x not in old]
 
-    if hasattr(old_value, "__sub__") and hasattr(new_value, "__sub__"):
-        return new_value - old_value
+    if hasattr(old, "__sub__") and hasattr(new, "__sub__"):
+        return new - old
 
     return None
 
@@ -40,12 +76,12 @@ class Filter(ABC):
     """Represents base for value callback modifiers."""
 
     _callback: Any
-    _value: Any
+    _value: Any = UNDEFINED
 
     def __init__(self, callback: EventCallbackType):
         """Initialize new Filter object."""
         self._callback = callback
-        self._value = None
+        self._value = UNDEFINED
 
     def __eq__(self, other) -> bool:
         """Compare debounced callbacks."""
@@ -59,21 +95,21 @@ class Filter(ABC):
 
     @abstractmethod
     async def __call__(self, new_value):
-        """Set new value for the callback."""
+        """Set a new value for the callback."""
 
 
 class _OnChange(Filter):
     """Provides changed functionality to the callback."""
 
     async def __call__(self, new_value):
-        """Set new value for the callback."""
+        """Set a new value for the callback."""
         if _significantly_changed(self._value, new_value):
             self._value = new_value
             return await self._callback(new_value)
 
 
 def on_change(callback: EventCallbackType) -> _OnChange:
-    """Helper for change callback filter."""
+    """Helper for a change callback filter."""
     return _OnChange(callback)
 
 
@@ -90,20 +126,20 @@ class _Debounce(Filter):
         self._min_calls = min_calls
 
     async def __call__(self, new_value):
-        """Set new value for the callback."""
+        """Set a new value for the callback."""
         if _significantly_changed(self._value, new_value):
             self._calls += 1
         else:
             self._calls = 0
 
-        if self._calls >= self._min_calls or self._value is None:
+        if self._value == UNDEFINED or self._calls >= self._min_calls:
             self._value = new_value
             self._calls = 0
             return await self._callback(new_value)
 
 
 def debounce(callback: EventCallbackType, min_calls) -> _Debounce:
-    """Helper method for debounce callback filter."""
+    """Helper method for a debounce callback filter."""
     return _Debounce(callback, min_calls)
 
 
@@ -120,7 +156,7 @@ class _Throttle(Filter):
         self._timeout = seconds
 
     async def __call__(self, new_value):
-        """set new value for the callback."""
+        """Set a new value for the callback."""
         current_timestamp = time.monotonic()
         if (
             self._last_called is None
@@ -131,7 +167,7 @@ class _Throttle(Filter):
 
 
 def throttle(callback: EventCallbackType, seconds: float) -> _Throttle:
-    """Helper method for throttle callback filter."""
+    """Helper method for a throttle callback filter."""
     return _Throttle(callback, seconds)
 
 
@@ -139,16 +175,16 @@ class _Delta(Filter):
     """Provides ability to pass call difference to the callback."""
 
     async def __call__(self, new_value):
-        """set new value for the callback."""
-        old_value = self._value
-        if _significantly_changed(old_value, new_value):
+        """Set new value for the callback."""
+        if _significantly_changed(self._value, new_value):
+            old_value = self._value
             self._value = new_value
             if (difference := _diffence_between(old_value, new_value)) is not None:
                 return await self._callback(difference)
 
 
 def delta(callback: EventCallbackType) -> _Delta:
-    """Helper method for delta callback filter."""
+    """Helper method for a delta callback filter."""
     return _Delta(callback)
 
 
@@ -168,7 +204,7 @@ class _Aggregate(Filter):
         self._sum = 0.0
 
     async def __call__(self, new_value):
-        """Set new value for the callback."""
+        """Set a new value for the callback."""
         current_timestamp = time.monotonic()
         try:
             self._sum += new_value
@@ -185,5 +221,5 @@ class _Aggregate(Filter):
 
 
 def aggregate(callback: EventCallbackType, seconds: float) -> _Aggregate:
-    """Helper method for total callback filter."""
+    """Helper method for a total callback filter."""
     return _Aggregate(callback, seconds)

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/helpers/typing.py

@@ -2,9 +2,17 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from typing import Any, Literal, Union
+from typing import Any, Literal, Protocol, Union
 
 ParameterDataType = tuple[int, int, int]
 ParameterValueType = Union[int, float, bool, Literal["off"], Literal["on"]]
 EventDataType = dict[Union[str, int], Any]
 EventCallbackType = Callable[[Any], Awaitable[Any]]
+UndefinedType = Literal["undefined"]
+
+
+class SupportsSubtraction(Protocol):
+    """Supports subtraction operation."""
+
+    def __sub__(self, other):
+        """Subtracts a value."""

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/structures/ecomax_parameters.py

@@ -10,13 +10,15 @@ from pyplumio.devices import Addressable
 from pyplumio.frames import Request
 from pyplumio.helpers.factory import factory
 from pyplumio.helpers.parameter import BinaryParameter, Parameter, ParameterDescription
-from pyplumio.helpers.typing import EventDataType, ParameterDataType, ParameterValueType
+from pyplumio.helpers.typing import EventDataType, ParameterValueType
 from pyplumio.structures import StructureDecoder, ensure_device_data
 from pyplumio.structures.thermostat_parameters import ATTR_THERMOSTAT_PROFILE
 
 ATTR_ECOMAX_CONTROL: Final = "ecomax_control"
 ATTR_ECOMAX_PARAMETERS: Final = "ecomax_parameters"
 
+ECOMAX_PARAMETER_SIZE: Final = 3
+
 
 class EcomaxParameter(Parameter):
     """Represents ecoMAX parameter."""
@@ -301,22 +303,33 @@ THERMOSTAT_PROFILE_PARAMETER = EcomaxParameterDescription(name=ATTR_THERMOSTAT_P
 class EcomaxParametersStructure(StructureDecoder):
     """Represents ecoMAX parameters data structure."""
 
+    _offset: int
+
+    def _ecomax_parameter(self, message: bytearray, start: int, end: int):
+        """Yields ecoMAX parameters."""
+        for index in range(start, start + end):
+            if parameter := util.unpack_parameter(message, self._offset):
+                yield (index, parameter)
+
+            self._offset += ECOMAX_PARAMETER_SIZE
+
     def decode(
         self, message: bytearray, offset: int = 0, data: EventDataType | None = None
     ) -> tuple[EventDataType, int]:
         """Decode bytes and return message data and offset."""
-        first_index = message[offset + 1]
-        last_index = message[offset + 2]
-        offset += 3
-        ecomax_parameters: list[tuple[int, ParameterDataType]] = []
-        for index in range(first_index, first_index + last_index):
-            parameter = util.unpack_parameter(message, offset)
-            if parameter is not None:
-                ecomax_parameters.append((index, parameter))
 
-            offset += 3
+        start = message[offset + 1]
+        end = message[offset + 2]
+        self._offset = offset + 3
 
         return (
-            ensure_device_data(data, {ATTR_ECOMAX_PARAMETERS: ecomax_parameters}),
-            offset,
+            ensure_device_data(
+                data,
+                {
+                    ATTR_ECOMAX_PARAMETERS: list(
+                        self._ecomax_parameter(message, start, end)
+                    )
+                },
+            ),
+            self._offset,
         )

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/structures/mixer_parameters.py

@@ -1,7 +1,6 @@
 """Contains mixer parameter structure decoder."""
 from __future__ import annotations
 
-from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Final
 
@@ -18,6 +17,8 @@ if TYPE_CHECKING:
 
 ATTR_MIXER_PARAMETERS: Final = "mixer_parameters"
 
+MIXER_PARAMETER_SIZE: Final = 3
+
 
 class MixerParameter(Parameter):
     """Represents mixer parameter."""
@@ -117,48 +118,41 @@ ECOMAX_I_MIXER_PARAMETERS: tuple[MixerParameterDescription, ...] = (
 )
 
 
-def _decode_mixer_parameters(
-    message: bytearray, offset: int, indexes: Iterable
-) -> tuple[list[tuple[int, ParameterDataType]], int]:
-    """Decode parameters for a single mixer."""
-    parameters: list[tuple[int, ParameterDataType]] = []
-    for index in indexes:
-        parameter = util.unpack_parameter(message, offset)
-        if parameter is not None:
-            parameters.append((index, parameter))
+class MixerParametersStructure(StructureDecoder):
+    """Represent mixer parameters data structure."""
 
-        offset += 3
+    _offset: int
 
-    return parameters, offset
+    def _mixer_parameter(self, message: bytearray, start: int, end: int):
+        """Yields mixer parameters."""
+        for index in range(start, start + end):
+            if (parameter := util.unpack_parameter(message, self._offset)) is not None:
+                yield (index, parameter)
 
-
-class MixerParametersStructure(StructureDecoder):
-    """Represent mixer parameters data structure."""
+            self._offset += MIXER_PARAMETER_SIZE
 
     def decode(
         self, message: bytearray, offset: int = 0, data: EventDataType | None = None
     ) -> tuple[EventDataType, int]:
         """Decode bytes and return message data and offset."""
-        first_index = message[offset + 1]
-        last_index = message[offset + 2]
-        mixer_count = message[offset + 3]
-        parameter_count_per_mixer = first_index + last_index
-        offset += 4
+        start = message[offset + 1]
+        end = message[offset + 2]
+        mixers = message[offset + 3]
+        self._offset = offset + 4
+
         mixer_parameters: dict[int, list[tuple[int, ParameterDataType]]] = {}
-        for index in range(mixer_count):
-            parameters, offset = _decode_mixer_parameters(
-                message,
-                offset,
-                range(first_index, parameter_count_per_mixer),
-            )
-            if parameters:
-                mixer_parameters[index] = parameters
-
-        if not mixer_parameters:
-            # No mixer parameters detected.
-            return ensure_device_data(data, {ATTR_MIXER_PARAMETERS: None}), offset
+        for mixer in range(mixers):
+            if parameters := list(self._mixer_parameter(message, start, end)):
+                mixer_parameters[mixer] = parameters
 
         return (
-            ensure_device_data(data, {ATTR_MIXER_PARAMETERS: mixer_parameters}),
-            offset,
+            ensure_device_data(
+                data,
+                {
+                    ATTR_MIXER_PARAMETERS: (
+                        None if not mixer_parameters else mixer_parameters
+                    )
+                },
+            ),
+            self._offset,
         )

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/pyplumio/structures/thermostat_parameters.py

@@ -1,7 +1,6 @@
 """Contains thermostat parameter structure decoder."""
 from __future__ import annotations
 
-from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Final
 
@@ -14,12 +13,15 @@ from pyplumio.helpers.typing import EventDataType, ParameterDataType, ParameterV
 from pyplumio.structures import StructureDecoder, ensure_device_data
 from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTAT_COUNT
 
+if TYPE_CHECKING:
+    from pyplumio.devices.thermostat import Thermostat
+
+
 ATTR_THERMOSTAT_PROFILE: Final = "thermostat_profile"
 ATTR_THERMOSTAT_PARAMETERS: Final = "thermostat_parameters"
 ATTR_THERMOSTAT_PARAMETERS_DECODER: Final = "thermostat_parameters_decoder"
 
-if TYPE_CHECKING:
-    from pyplumio.devices.thermostat import Thermostat
+THERMOSTAT_PARAMETER_SIZE: Final = 3
 
 
 class ThermostatParameter(Parameter):
@@ -107,72 +109,68 @@ THERMOSTAT_PARAMETERS: tuple[ThermostatParameterDescription, ...] = (
 )
 
 
-def _decode_thermostat_parameters(
-    message: bytearray, offset: int, indexes: Iterable
-) -> tuple[list[tuple[int, ParameterDataType]], int]:
-    """Decode parameters for a single thermostat."""
-    parameters: list[tuple[int, ParameterDataType]] = []
-    for index in indexes:
-        description = THERMOSTAT_PARAMETERS[index]
-        parameter = util.unpack_parameter(message, offset, size=description.size)
-        if parameter is not None:
-            parameters.append((index, parameter))
-
-        offset += 3 * description.size
-
-    return parameters, offset
+def _empty_response(
+    offset: int, data: EventDataType | None = None
+) -> tuple[EventDataType, int]:
+    """Return empty response."""
+    return (
+        ensure_device_data(
+            data,
+            {ATTR_THERMOSTAT_PARAMETERS: None, ATTR_THERMOSTAT_PROFILE: None},
+        ),
+        offset,
+    )
 
 
 class ThermostatParametersStructure(StructureDecoder):
     """Represent thermostat parameters data structure."""
 
+    _offset: int
+
+    def _thermostat_parameter(
+        self, message: bytearray, thermostats: int, start: int, end: int
+    ):
+        """Yields thermostat parameters."""
+        for index in range(start, (start + end) // thermostats):
+            description = THERMOSTAT_PARAMETERS[index]
+            if (
+                parameter := util.unpack_parameter(
+                    message, self._offset, size=description.size
+                )
+            ) is not None:
+                yield (index, parameter)
+
+            self._offset += THERMOSTAT_PARAMETER_SIZE * description.size
+
     def decode(
         self, message: bytearray, offset: int = 0, data: EventDataType | None = None
     ) -> tuple[EventDataType, int]:
         """Decode bytes and return message data and offset."""
         data = ensure_device_data(data)
-        thermostat_count = data.get(ATTR_THERMOSTAT_COUNT, 0)
-        if thermostat_count == 0:
-            return (
-                ensure_device_data(
-                    data,
-                    {ATTR_THERMOSTAT_PARAMETERS: None, ATTR_THERMOSTAT_PROFILE: None},
-                ),
-                offset,
-            )
-
-        first_index = message[offset + 1]
-        last_index = message[offset + 2]
+        thermostats = data.get(ATTR_THERMOSTAT_COUNT, 0)
+        if thermostats == 0:
+            return _empty_response(offset, data)
+
+        start = message[offset + 1]
+        end = message[offset + 2]
         thermostat_profile = util.unpack_parameter(message, offset + 3)
-        parameter_count_per_thermostat = (first_index + last_index) // thermostat_count
-        offset += 6
+        self._offset = offset + 6
         thermostat_parameters: dict[int, list[tuple[int, ParameterDataType]]] = {}
-        for index in range(thermostat_count):
-            parameters, offset = _decode_thermostat_parameters(
-                message,
-                offset,
-                range(first_index, parameter_count_per_thermostat),
-            )
-            if parameters:
-                thermostat_parameters[index] = parameters
-
-        if not thermostat_parameters:
-            # No thermostat parameters detected.
-            return (
-                ensure_device_data(
-                    data,
-                    {ATTR_THERMOSTAT_PARAMETERS: None, ATTR_THERMOSTAT_PROFILE: None},
-                ),
-                offset,
-            )
+        for thermostat in range(thermostats):
+            if parameters := list(
+                self._thermostat_parameter(message, thermostats, start, end)
+            ):
+                thermostat_parameters[thermostat] = parameters
 
         return (
             ensure_device_data(
                 data,
                 {
                     ATTR_THERMOSTAT_PROFILE: thermostat_profile,
-                    ATTR_THERMOSTAT_PARAMETERS: thermostat_parameters,
+                    ATTR_THERMOSTAT_PARAMETERS: None
+                    if not thermostat_parameters
+                    else thermostat_parameters,
                 },
             ),
-            offset,
+            self._offset,
         )

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/tests/test_devices.py

@@ -7,6 +7,7 @@ import pytest
 
 from pyplumio.const import (
     ATTR_DEVICE_INDEX,
+    ATTR_FRAME_ERRORS,
     ATTR_INDEX,
     ATTR_LOADED,
     ATTR_OFFSET,
@@ -117,6 +118,7 @@ async def test_async_setup() -> None:
         await ecomax.wait_until_done()
 
     assert await ecomax.get(ATTR_LOADED)
+    assert not ecomax.data[ATTR_FRAME_ERRORS]
     assert mock_request.await_count == len(DATA_FRAME_TYPES)
 
 
@@ -126,13 +128,22 @@ async def test_async_setup_error(caplog) -> None:
 
     with patch("pyplumio.devices.ecomax.EcoMAX.wait_for"), patch(
         "pyplumio.devices.ecomax.EcoMAX.request",
-        side_effect=(ValueError("test"), True, True, True, True, True, True, True),
+        side_effect=(
+            ValueError("test", FrameType.REQUEST_ALERTS),
+            True,
+            True,
+            True,
+            True,
+            True,
+            True,
+            True,
+        ),
     ) as mock_request:
         await ecomax.async_setup()
         await ecomax.wait_until_done()
 
-    assert "Request failed" in caplog.text
-    assert not await ecomax.get(ATTR_LOADED)
+    assert await ecomax.get(ATTR_LOADED)
+    assert ecomax.data[ATTR_FRAME_ERRORS][0] == FrameType.REQUEST_ALERTS
     assert mock_request.await_count == len(DATA_FRAME_TYPES)
 
 

{PyPlumIO-0.4.0.post1 → PyPlumIO-0.4.2}/tests/test_filters.py

@@ -6,6 +6,7 @@ from unittest.mock import AsyncMock, patch
 import pytest
 
 from pyplumio.filters import aggregate, debounce, delta, on_change, throttle
+from pyplumio.helpers.parameter import Parameter
 from pyplumio.structures.alerts import Alert
 
 
@@ -31,6 +32,63 @@ async def test_on_change() -> None:
         _ = wrapped_callback == "you shall not pass"
 
 
+async def test_on_change_parameter() -> None:
+    """Test on change filter with parameters."""
+    test_callback = AsyncMock()
+    test_parameter = AsyncMock(spec=Parameter)
+    test_parameter.value = 0
+    test_parameter.min_value = 0
+    test_parameter.max_value = 1
+    test_parameter.is_changed = False
+    wrapped_callback = on_change(test_callback)
+    await wrapped_callback(test_parameter)
+    test_callback.assert_awaited_once_with(test_parameter)
+    test_callback.reset_mock()
+
+    # Check that callback is not awaited with no change.
+    await wrapped_callback(test_parameter)
+    test_callback.assert_not_awaited()
+
+    # Check that callback is awaited on local value change.
+    test_parameter = AsyncMock(spec=Parameter)
+    test_parameter.value = 1
+    test_parameter.min_value = 0
+    test_parameter.max_value = 1
+    test_parameter.is_changed = True
+    await wrapped_callback(test_parameter)
+    test_callback.assert_awaited_once_with(test_parameter)
+    test_callback.reset_mock()
+
+    # Check that callback is awaited on value change.
+    test_parameter = AsyncMock(spec=Parameter)
+    test_parameter.value = 1
+    test_parameter.min_value = 0
+    test_parameter.max_value = 1
+    test_parameter.is_changed = False
+    await wrapped_callback(test_parameter)
+    test_callback.assert_awaited_once_with(test_parameter)
+    test_callback.reset_mock()
+
+    # Check that callback is awaited on min value change.
+    test_parameter = AsyncMock(spec=Parameter)
+    test_parameter.value = 1
+    test_parameter.min_value = 1
+    test_parameter.max_value = 1
+    test_parameter.is_changed = False
+    await wrapped_callback(test_parameter)
+    test_callback.assert_awaited_once_with(test_parameter)
+    test_callback.reset_mock()
+
+    # Check that callback is awaited on max value change.
+    test_parameter = AsyncMock(spec=Parameter)
+    test_parameter.value = 1
+    test_parameter.min_value = 1
+    test_parameter.max_value = 2
+    test_parameter.is_changed = False
+    await wrapped_callback(test_parameter)
+    test_callback.assert_awaited_once_with(test_parameter)
+
+
 async def test_debounce() -> None:
     """Test debounce filter."""
     test_callback = AsyncMock()

PyPlumIO-0.4.0.post1/pyplumio/_version.py

@@ -1,4 +0,0 @@
-# file generated by setuptools_scm
-# don't change, don't track in version control
-__version__ = version = '0.4.0.post1'
-__version_tuple__ = version_tuple = (0, 4, 0)