PyPlumIO 0.5.52__tar.gz → 0.5.53__tar.gz

{pyplumio-0.5.52 → pyplumio-0.5.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.52
+Version: 0.5.53
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dataslots==1.2.0
 Requires-Dist: pyserial-asyncio==0.6
-Requires-Dist: typing-extensions==4.14.0
+Requires-Dist: typing-extensions<5.0,>=4.14.0
 Provides-Extra: test
 Requires-Dist: codespell==2.4.1; extra == "test"
 Requires-Dist: coverage==7.9.1; extra == "test"
@@ -35,8 +35,8 @@ Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
 Requires-Dist: pytest==8.4.1; extra == "test"
 Requires-Dist: pytest-asyncio==1.0.0; extra == "test"
-Requires-Dist: ruff==0.11.13; extra == "test"
-Requires-Dist: tox==4.26.0; extra == "test"
+Requires-Dist: ruff==0.12.1; extra == "test"
+Requires-Dist: tox==4.27.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20250326; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"

{pyplumio-0.5.52 → pyplumio-0.5.53}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.52
+Version: 0.5.53
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dataslots==1.2.0
 Requires-Dist: pyserial-asyncio==0.6
-Requires-Dist: typing-extensions==4.14.0
+Requires-Dist: typing-extensions<5.0,>=4.14.0
 Provides-Extra: test
 Requires-Dist: codespell==2.4.1; extra == "test"
 Requires-Dist: coverage==7.9.1; extra == "test"
@@ -35,8 +35,8 @@ Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
 Requires-Dist: pytest==8.4.1; extra == "test"
 Requires-Dist: pytest-asyncio==1.0.0; extra == "test"
-Requires-Dist: ruff==0.11.13; extra == "test"
-Requires-Dist: tox==4.26.0; extra == "test"
+Requires-Dist: ruff==0.12.1; extra == "test"
+Requires-Dist: tox==4.27.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20250326; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"

{pyplumio-0.5.52 → pyplumio-0.5.53}/PyPlumIO.egg-info/SOURCES.txt

@@ -63,7 +63,6 @@ pyplumio/helpers/async_cache.py
 pyplumio/helpers/event_manager.py
 pyplumio/helpers/factory.py
 pyplumio/helpers/task_manager.py
-pyplumio/helpers/timeout.py
 pyplumio/parameters/__init__.py
 pyplumio/parameters/ecomax.py
 pyplumio/parameters/mixer.py
@@ -122,7 +121,6 @@ tests/helpers/test_async_cache.py
 tests/helpers/test_event_manager.py
 tests/helpers/test_factory.py
 tests/helpers/test_task_manager.py
-tests/helpers/test_timeout.py
 tests/helpers/test_uid.py
 tests/parameters/__init__.py
 tests/parameters/test_ecomax.py

{pyplumio-0.5.52 → pyplumio-0.5.53}/PyPlumIO.egg-info/requires.txt

@@ -1,6 +1,6 @@
 dataslots==1.2.0
 pyserial-asyncio==0.6
-typing-extensions==4.14.0
+typing-extensions<5.0,>=4.14.0
 
 [dev]
 pyplumio[docs,test]
@@ -21,6 +21,6 @@ numpy<3.0.0,>=2.0.0
 pyserial-asyncio-fast==0.16
 pytest==8.4.1
 pytest-asyncio==1.0.0
-ruff==0.11.13
-tox==4.26.0
+ruff==0.12.1
+tox==4.27.0
 types-pyserial==3.5.0.20250326

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.52'
-__version_tuple__ = version_tuple = (0, 5, 52)
+__version__ = version = '0.5.53'
+__version_tuple__ = version_tuple = (0, 5, 53)

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/connection.py

@@ -11,8 +11,8 @@ from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE
 
 from pyplumio.exceptions import ConnectionFailedError
 from pyplumio.helpers.task_manager import TaskManager
-from pyplumio.helpers.timeout import timeout
 from pyplumio.protocol import AsyncProtocol, Protocol
+from pyplumio.utils import timeout
 
 _LOGGER = logging.getLogger(__name__)
 

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/data_types.py

@@ -33,6 +33,13 @@ class DataType(ABC, Generic[T]):
 
         return f"{self.__class__.__name__}()"
 
+    def __hash__(self) -> int:
+        """Return a hash of the data type based on its value."""
+        if hasattr(self, "_value"):
+            return hash(self._value)
+
+        return hash(type(self))
+
     def __eq__(self, other: object) -> bool:
         """Compare if this data type is equal to other."""
         if (

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/filters.py

@@ -56,6 +56,9 @@ class SupportsComparison(Protocol):
 
     __slots__ = ()
 
+    def __hash__(self) -> int:
+        """Return a hash of the value."""
+
     def __eq__(self: SupportsComparison, other: SupportsComparison) -> bool:
         """Compare a value."""
 
@@ -130,6 +133,10 @@ class Filter(ABC):
         self._callback = callback
         self._value = UNDEFINED
 
+    def __hash__(self) -> int:
+        """Return a hash of the filter based on its callback."""
+        return hash(self._callback)
+
     def __eq__(self, other: Any) -> bool:
         """Compare callbacks."""
         if isinstance(other, Filter):

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/frames/__init__.py

@@ -114,6 +114,19 @@ class Frame(ABC):
         self._data = data if not kwargs else ensure_dict(data, kwargs)
         self._message = message
 
+    def __hash__(self) -> int:
+        """Return a hash of the frame based on its values."""
+        return hash(
+            (
+                self.recipient,
+                self.sender,
+                self.econet_type,
+                self.econet_version,
+                self._message,
+                frozenset(self._data.items()) if self._data else None,
+            )
+        )
+
     def __eq__(self, other: object) -> bool:
         """Compare if this frame is equal to other."""
         if isinstance(other, Frame):

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/parameters/__init__.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import asyncio
 from contextlib import suppress
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 import logging
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, get_args
 
@@ -115,6 +115,10 @@ class Parameter(ABC):
             f"index={self._index})"
         )
 
+    def __hash__(self) -> int:
+        """Return a hash of the parameter based on its values."""
+        return hash(frozenset(asdict(self.values).items()))
+
     def _call_relational_method(self, method_to_call: str, other: Any) -> Any:
         """Call a specified relational method."""
         if isinstance(other, Parameter):

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/stream.py

@@ -20,7 +20,7 @@ from pyplumio.frames import (
     bcc,
     struct_header,
 )
-from pyplumio.helpers.timeout import timeout
+from pyplumio.utils import timeout
 
 READER_TIMEOUT: Final = 10
 WRITER_TIMEOUT: Final = 10
@@ -67,7 +67,7 @@ class FrameWriter:
         await self._writer.wait_closed()
 
 
-class BufferManager:
+class BufferedReader:
     """Represents a buffered reader for reading frames."""
 
     __slots__ = ("_buffer", "_reader")
@@ -89,7 +89,7 @@ class BufferManager:
         try:
             data = await self._reader.readexactly(bytes_to_read)
             self._buffer.extend(data)
-            self.trim_to(size)
+            self.trim_to(DEFAULT_BUFFER_SIZE)
         except IncompleteReadError as e:
             raise ReadError(
                 f"Incomplete read. Tried to read {bytes_to_read} additional bytes "
@@ -104,22 +104,36 @@ class BufferManager:
                 f"Serial connection broken while trying to ensure {size} bytes: {e}"
             ) from e
 
+    async def peek(self, size: int) -> bytes:
+        """Read the specified number of bytes without consuming them."""
+        await self.ensure_buffer(size)
+        return memoryview(self._buffer)[:size].tobytes()
+
     async def consume(self, size: int) -> None:
         """Consume the specified number of bytes from the buffer."""
         await self.ensure_buffer(size)
         self._buffer = self._buffer[size:]
 
-    async def peek(self, size: int) -> bytearray:
-        """Read the specified number of bytes without consuming them."""
-        await self.ensure_buffer(size)
-        return self._buffer[:size]
-
-    async def read(self, size: int) -> bytearray:
-        """Read the bytes from buffer or stream and consume them."""
+    async def read_into_buffer(self, size: int) -> None:
+        """Read the specified number of bytes from the stream."""
         try:
-            return await self.peek(size)
-        finally:
-            await self.consume(size)
+            chunk = await self._reader.read(size)
+        except asyncio.CancelledError:
+            _LOGGER.debug("Read operation cancelled while filling internal buffer.")
+            raise
+        except Exception as e:
+            raise OSError(
+                f"Serial connection broken while filling internal buffer: {e}"
+            ) from e
+
+        if not chunk:
+            _LOGGER.debug("Stream ended while filling internal buffer.")
+            raise OSError(
+                "Serial connection broken: stream ended while filling internal buffer"
+            )
+
+        self._buffer.extend(chunk)
+        self.trim_to(DEFAULT_BUFFER_SIZE)
 
     def seek_to(self, delimiter: SupportsIndex) -> bool:
         """Trim the buffer to the first occurrence of the delimiter.
@@ -137,27 +151,6 @@ class BufferManager:
         if len(self._buffer) > size:
             self._buffer = self._buffer[-size:]
 
-    async def fill(self) -> None:
-        """Fill the buffer with data from the stream."""
-        try:
-            chunk = await self._reader.read(MAX_FRAME_LENGTH)
-        except asyncio.CancelledError:
-            _LOGGER.debug("Read operation cancelled while filling read buffer.")
-            raise
-        except Exception as e:
-            raise OSError(
-                f"Serial connection broken while filling read buffer: {e}"
-            ) from e
-
-        if not chunk:
-            _LOGGER.debug("Stream ended while filling read buffer.")
-            raise OSError(
-                "Serial connection broken: stream ended while filling read buffer"
-            )
-
-        self._buffer.extend(chunk)
-        self.trim_to(DEFAULT_BUFFER_SIZE)
-
     @property
     def buffer(self) -> bytearray:
         """Return the internal buffer."""
@@ -177,22 +170,23 @@ class Header(NamedTuple):
 class FrameReader:
     """Represents a frame reader."""
 
-    __slots__ = ("_buffer",)
+    __slots__ = ("_reader",)
 
-    _buffer: BufferManager
+    _reader: BufferedReader
 
     def __init__(self, reader: StreamReader) -> None:
         """Initialize a new frame reader."""
-        self._buffer = BufferManager(reader)
+        self._reader = BufferedReader(reader)
 
     async def _read_header(self) -> Header:
         """Locate and read a frame header."""
         while True:
-            if self._buffer.seek_to(FRAME_START):
-                header_bytes = await self._buffer.peek(HEADER_SIZE)
-                return Header(*struct_header.unpack_from(header_bytes)[DELIMITER_SIZE:])
+            if self._reader.seek_to(FRAME_START):
+                header_bytes = await self._reader.peek(HEADER_SIZE)
+                header_fields = struct_header.unpack_from(header_bytes)
+                return Header(*header_fields[DELIMITER_SIZE:])
 
-            await self._buffer.fill()
+            await self._reader.read_into_buffer(MAX_FRAME_LENGTH)
 
     @timeout(READER_TIMEOUT)
     async def read(self) -> Frame | None:
@@ -201,22 +195,22 @@ class FrameReader:
         frame_length, recipient, sender, econet_type, econet_version = header
 
         if frame_length > MAX_FRAME_LENGTH or frame_length < MIN_FRAME_LENGTH:
-            await self._buffer.consume(HEADER_SIZE)
+            await self._reader.consume(HEADER_SIZE)
             raise ReadError(
                 f"Unexpected frame length ({frame_length}), expected between "
                 f"{MIN_FRAME_LENGTH} and {MAX_FRAME_LENGTH}"
             )
 
-        frame_bytes = await self._buffer.peek(frame_length)
+        frame_bytes = await self._reader.peek(frame_length)
         checksum = bcc(frame_bytes[:BCC_INDEX])
         if checksum != frame_bytes[BCC_INDEX]:
-            await self._buffer.consume(HEADER_SIZE)
+            await self._reader.consume(HEADER_SIZE)
             raise ChecksumError(
                 f"Incorrect frame checksum: calculated {checksum}, "
                 f"expected {frame_bytes[BCC_INDEX]}. Frame data: {frame_bytes.hex()}"
             )
 
-        await self._buffer.consume(frame_length)
+        await self._reader.consume(frame_length)
         if recipient not in (DeviceType.ECONET, DeviceType.ALL):
             _LOGGER.debug(
                 "Skipping frame intended for different recipient (%s)", recipient

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyplumio/utils.py

@@ -2,9 +2,13 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+import asyncio
+from collections.abc import Awaitable, Callable, Mapping
+from functools import wraps
 from typing import TypeVar
 
+from typing_extensions import ParamSpec
+
 KT = TypeVar("KT")  # Key type.
 VT = TypeVar("VT")  # Value type.
 
@@ -40,4 +44,24 @@ def is_divisible(a: float, b: float, precision: int = 6) -> bool:
     return a_scaled % b_scaled == 0
 
 
-__all__ = ["ensure_dict", "is_divisible", "to_camelcase"]
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def timeout(
+    seconds: float,
+) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Awaitable[T]]]:
+    """Decorate a timeout for the awaitable."""
+
+    def decorator(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
+        @wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
+
+        setattr(wrapper, "_has_timeout_seconds", seconds)
+        return wrapper
+
+    return decorator
+
+
+__all__ = ["ensure_dict", "is_divisible", "to_camelcase", "timeout"]

{pyplumio-0.5.52 → pyplumio-0.5.53}/pyproject.toml

@@ -26,7 +26,7 @@ classifiers = [
 dependencies = [
     "dataslots==1.2.0",
     "pyserial-asyncio==0.6",
-    "typing-extensions==4.14.0"
+    "typing-extensions>=4.14.0,<5.0"
 ]
 dynamic = ["version"]
 
@@ -45,8 +45,8 @@ test = [
     "pyserial-asyncio-fast==0.16",
     "pytest==8.4.1",
     "pytest-asyncio==1.0.0",
-    "ruff==0.11.13",
-    "tox==4.26.0",
+    "ruff==0.12.1",
+    "tox==4.27.0",
     "types-pyserial==3.5.0.20250326"
 ]
 docs = [

{pyplumio-0.5.52 → pyplumio-0.5.53}/requirements.txt

@@ -1,3 +1,3 @@
 dataslots==1.2.0
 pyserial-asyncio==0.6
-typing-extensions==4.14.0
+typing-extensions>=4.14.0,<5.0

{pyplumio-0.5.52 → pyplumio-0.5.53}/requirements_test.txt

@@ -7,7 +7,7 @@ pre-commit==4.2.0
 pyserial-asyncio-fast==0.16
 pytest-asyncio==1.0.0
 pytest==8.4.1
-ruff==0.11.13
+ruff==0.12.1
 tomli==2.2.1
-tox==4.26.0
+tox==4.27.0
 types-pyserial==3.5.0.20250326

{pyplumio-0.5.52 → pyplumio-0.5.53}/tests/parameters/test_init.py

@@ -139,6 +139,15 @@ class TestParameter:
         assert result == 6
         assert isinstance(result, int)
 
+    def test_hash(self, parameter: Parameter) -> None:
+        """Test __hash__.
+
+        Checks parameter hashing.
+        """
+        assert hash(parameter) == hash(
+            frozenset({("value", 6), ("min_value", 0), ("max_value", 10)})
+        )
+
     @pytest.mark.parametrize(
         ("func_name", "other", "expected_result", "expected_type"),
         [

{pyplumio-0.5.52 → pyplumio-0.5.53}/tests/test_connection.py

@@ -6,22 +6,21 @@ from asyncio import StreamReader, StreamWriter
 from importlib import reload
 import logging
 import sys
-from typing import Final
+from typing import Any, Final
 from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE
 
+import pyplumio.connection
 from pyplumio.connection import Connection, SerialConnection, TcpConnection
 from pyplumio.exceptions import ConnectionFailedError
 from pyplumio.protocol import Protocol
 
 
 @pytest.fixture(name="use_fast", params=(True, False))
-def fixture_use_fast(request, monkeypatch, caplog):
+def fixture_use_fast(request, monkeypatch, caplog) -> Any:
     """Try with and without serial-asyncio-fast package."""
-    import pyplumio.connection
-
     if not request.param:
         monkeypatch.setitem(sys.modules, "serial_asyncio_fast", None)
 

{pyplumio-0.5.52 → pyplumio-0.5.53}/tests/test_data_types.py

@@ -47,6 +47,7 @@ def test_data_type(
 
     assert data_type.size == len(buffer)
     assert data_type.to_bytes() == buffer
+    assert hash(data_type) == hash(expected)
     assert repr(data_type) == f"{cls.__qualname__}(value={expected})"
 
     if not isinstance(
@@ -56,6 +57,12 @@ def test_data_type(
         assert cls().__eq__(UNDEFINED) is NotImplemented
 
 
+def test_hash_no_value() -> None:
+    """Test data type hash with no value."""
+    undefined = data_types.Undefined()
+    assert hash(undefined) == hash(type(undefined))
+
+
 def test_bitarray() -> None:
     """Test a bit array data type."""
     buffer = bytearray([0x55])

{pyplumio-0.5.52 → pyplumio-0.5.53}/tests/test_filters.py

@@ -45,6 +45,7 @@ async def test_clamp(input_value, expected) -> None:
     """Test the clamp filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.clamp(test_callback, min_value=10, max_value=15)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(input_value)
     test_callback.assert_awaited_once_with(expected)
 
@@ -53,6 +54,7 @@ async def test_deadband() -> None:
     """Test the deadband filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.deadband(test_callback, tolerance=0.1)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(1)
     test_callback.assert_awaited_once_with(1)
     test_callback.reset_mock()
@@ -73,6 +75,7 @@ async def test_on_change() -> None:
     """Test the value changed filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.on_change(test_callback)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(1)
     test_callback.assert_awaited_once_with(1)
     test_callback.reset_mock()
@@ -93,6 +96,7 @@ async def test_on_change_parameter() -> None:
     test_parameter.values = ParameterValues(0, 0, 1)
     test_parameter.update_pending.is_set = Mock(return_value=False)
     wrapped_callback = filters.on_change(test_callback)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(test_parameter)
     test_callback.assert_awaited_once_with(test_parameter)
     test_callback.reset_mock()
@@ -130,6 +134,7 @@ async def test_debounce() -> None:
     """Test the debounce filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.debounce(test_callback, min_calls=3)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(1)
     test_callback.assert_awaited_once_with(1)
     test_callback.reset_mock()
@@ -147,6 +152,7 @@ async def test_throttle(frozen_time) -> None:
     """Test the throttle filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.throttle(test_callback, seconds=5)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(1)
     test_callback.assert_awaited_once_with(1)
     test_callback.reset_mock()
@@ -172,6 +178,7 @@ async def test_delta() -> None:
     """Test the delta filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.delta(test_callback)
+    assert hash(wrapped_callback) == hash(test_callback)
 
     await wrapped_callback(5)
     test_callback.assert_not_awaited()
@@ -201,6 +208,7 @@ async def test_aggregate(use_numpy, frozen_time) -> None:
     """Test the aggregate filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.aggregate(test_callback, seconds=5, sample_size=5)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(1)
     test_callback.assert_not_awaited()
 
@@ -236,6 +244,7 @@ async def test_aggregate_sample_size(frozen_time) -> None:
     """Test the aggregate filter with sample size."""
     test_callback = AsyncMock()
     wrapped_callback = filters.aggregate(test_callback, seconds=5, sample_size=2)
+    assert hash(wrapped_callback) == hash(test_callback)
 
     # Zero seconds passed, current sample size is 1.
     await wrapped_callback(1)
@@ -264,6 +273,7 @@ async def test_custom(filter_func, input_value, callback) -> None:
     """Test the custom filter."""
     test_callback = AsyncMock()
     wrapped_callback = filters.custom(test_callback, filter_func)
+    assert hash(wrapped_callback) == hash(test_callback)
     await wrapped_callback(input_value)
 
     if callback: