PyPlumIO 0.4.1__tar.gz → 0.4.2__tar.gz

{PyPlumIO-0.4.1 → PyPlumIO-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.4.1
+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.1 → PyPlumIO-0.4.2}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.4.1
+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.1 → PyPlumIO-0.4.2}/pyplumio/_version.py

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

{PyPlumIO-0.4.1 → 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"

{PyPlumIO-0.4.1 → 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.1 → 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.1 → 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()