PyPlumIO 0.5.52__tar.gz → 0.5.54__tar.gz

{pyplumio-0.5.52 → pyplumio-0.5.54}/.pre-commit-config.yaml

@@ -3,7 +3,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.11
+    rev: v0.12.11
     hooks:
       - id: ruff
         args:
@@ -13,6 +13,6 @@ repos:
     hooks:
       - id: codespell
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.15.0
+    rev: v1.17.1
     hooks:
       - id: mypy

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.52
+Version: 0.5.54
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,26 +25,26 @@ 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"
-Requires-Dist: freezegun==1.5.2; extra == "test"
-Requires-Dist: mypy==1.16.1; extra == "test"
+Requires-Dist: coverage==7.10.5; extra == "test"
+Requires-Dist: freezegun==1.5.5; extra == "test"
+Requires-Dist: mypy==1.17.1; extra == "test"
 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: types-pyserial==3.5.0.20250326; extra == "test"
+Requires-Dist: pytest-asyncio==1.1.0; extra == "test"
+Requires-Dist: ruff==0.12.10; extra == "test"
+Requires-Dist: tox==4.28.4; extra == "test"
+Requires-Dist: types-pyserial==3.5.0.20250822; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"
 Requires-Dist: sphinx_rtd_theme==3.0.2; extra == "docs"
 Requires-Dist: readthedocs-sphinx-search==0.3.2; extra == "docs"
 Provides-Extra: dev
 Requires-Dist: pyplumio[docs,test]; extra == "dev"
-Requires-Dist: pre-commit==4.2.0; extra == "dev"
+Requires-Dist: pre-commit==4.3.0; extra == "dev"
 Requires-Dist: tomli==2.2.1; extra == "dev"
 Dynamic: license-file
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.52
+Version: 0.5.54
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,26 +25,26 @@ 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"
-Requires-Dist: freezegun==1.5.2; extra == "test"
-Requires-Dist: mypy==1.16.1; extra == "test"
+Requires-Dist: coverage==7.10.5; extra == "test"
+Requires-Dist: freezegun==1.5.5; extra == "test"
+Requires-Dist: mypy==1.17.1; extra == "test"
 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: types-pyserial==3.5.0.20250326; extra == "test"
+Requires-Dist: pytest-asyncio==1.1.0; extra == "test"
+Requires-Dist: ruff==0.12.10; extra == "test"
+Requires-Dist: tox==4.28.4; extra == "test"
+Requires-Dist: types-pyserial==3.5.0.20250822; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"
 Requires-Dist: sphinx_rtd_theme==3.0.2; extra == "docs"
 Requires-Dist: readthedocs-sphinx-search==0.3.2; extra == "docs"
 Provides-Extra: dev
 Requires-Dist: pyplumio[docs,test]; extra == "dev"
-Requires-Dist: pre-commit==4.2.0; extra == "dev"
+Requires-Dist: pre-commit==4.3.0; extra == "dev"
 Requires-Dist: tomli==2.2.1; extra == "dev"
 Dynamic: license-file
 

{pyplumio-0.5.52 → pyplumio-0.5.54}/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.54}/PyPlumIO.egg-info/requires.txt

@@ -1,10 +1,10 @@
 dataslots==1.2.0
 pyserial-asyncio==0.6
-typing-extensions==4.14.0
+typing-extensions<5.0,>=4.14.0
 
 [dev]
 pyplumio[docs,test]
-pre-commit==4.2.0
+pre-commit==4.3.0
 tomli==2.2.1
 
 [docs]
@@ -14,13 +14,13 @@ readthedocs-sphinx-search==0.3.2
 
 [test]
 codespell==2.4.1
-coverage==7.9.1
-freezegun==1.5.2
-mypy==1.16.1
+coverage==7.10.5
+freezegun==1.5.5
+mypy==1.17.1
 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
-types-pyserial==3.5.0.20250326
+pytest-asyncio==1.1.0
+ruff==0.12.10
+tox==4.28.4
+types-pyserial==3.5.0.20250822

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

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.52'
-__version_tuple__ = version_tuple = (0, 5, 52)
+__version__ = version = '0.5.54'
+__version_tuple__ = version_tuple = (0, 5, 54)
+
+__commit_id__ = commit_id = 'g7b7ef864f'

{pyplumio-0.5.52 → pyplumio-0.5.54}/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.54}/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.54}/pyplumio/devices/__init__.py

@@ -195,6 +195,7 @@ class PhysicalDevice(Device, ABC):
         """
         _LOGGER.info("Requesting '%s' with %s", name, repr(frame_type))
         request = await Request.create(frame_type, recipient=self.address)
+        initial_retries = retries
         while retries > 0:
             try:
                 self.queue.put_nowait(request)
@@ -204,7 +205,7 @@ class PhysicalDevice(Device, ABC):
 
         raise RequestError(
             f"Failed to request '{name}' with frame type '{frame_type}' after "
-            f"{retries} retries.",
+            f"{initial_retries} retries.",
             frame_type=frame_type,
         )
 

{pyplumio-0.5.52 → pyplumio-0.5.54}/pyplumio/devices/ecomax.py

@@ -236,7 +236,7 @@ class EcoMAX(PhysicalDevice):
     async def on_event_setup(self, setup: bool) -> None:
         """Request frames required to set up an ecoMAX entry."""
         _LOGGER.debug("Setting up device entry")
-        await self.wait_for(ATTR_SENSORS)
+        await self.wait_for(ATTR_SENSORS, timeout=30.0)
         results = await asyncio.gather(
             *(
                 self.request(description.provides, description.frame_type)

{pyplumio-0.5.52 → pyplumio-0.5.54}/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):
@@ -179,9 +186,10 @@ class _Aggregate(Filter):
         self._values.append(new_value)
         time_since_call = current_time - self._last_call_time
         if time_since_call >= self._timeout or len(self._values) >= self._sample_size:
-            result = await self._callback(
+            sum_of_values = (
                 np.sum(self._values) if numpy_installed else sum(self._values)
             )
+            result = await self._callback(float(sum_of_values))
             self._last_call_time = current_time
             self._values = []
             return result

{pyplumio-0.5.52 → pyplumio-0.5.54}/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.54}/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.54}/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.54}/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.54}/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"]
 
@@ -38,16 +38,16 @@ dynamic = ["version"]
 [project.optional-dependencies]
 test = [
     "codespell==2.4.1",
-    "coverage==7.9.1",
-    "freezegun==1.5.2",
-    "mypy==1.16.1",
+    "coverage==7.10.5",
+    "freezegun==1.5.5",
+    "mypy==1.17.1",
     "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",
-    "types-pyserial==3.5.0.20250326"
+    "pytest-asyncio==1.1.0",
+    "ruff==0.12.10",
+    "tox==4.28.4",
+    "types-pyserial==3.5.0.20250822"
 ]
 docs = [
     "sphinx==8.1.3",
@@ -56,7 +56,7 @@ docs = [
 ]
 dev = [
     "pyplumio[test,docs]",
-    "pre-commit==4.2.0",
+    "pre-commit==4.3.0",
     "tomli==2.2.1"
 ]
 

{pyplumio-0.5.52 → pyplumio-0.5.54}/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.54/requirements_test.txt

@@ -0,0 +1,13 @@
+codespell==2.4.1
+coverage==7.10.5
+freezegun==1.5.5
+mypy==1.17.1
+numpy<3.0.0,>=2.0.0
+pre-commit==4.3.0
+pyserial-asyncio-fast==0.16
+pytest-asyncio==1.1.0
+pytest==8.4.1
+ruff==0.12.10
+tomli==2.2.1
+tox==4.28.4
+types-pyserial==3.5.0.20250822

{pyplumio-0.5.52 → pyplumio-0.5.54}/tests/devices/test_ecomax.py

@@ -206,7 +206,7 @@ async def test_ecomax_setup(mock_wait_for, mock_request, ecomax: EcoMAX) -> None
     await ecomax.wait_until_done()
     assert ATTR_FRAME_ERRORS not in ecomax.data
     assert mock_request.await_count == len(REQUIRED)
-    mock_wait_for.assert_awaited_once_with(ATTR_SENSORS)
+    mock_wait_for.assert_awaited_once_with(ATTR_SENSORS, timeout=30.0)
 
 
 @patch(
@@ -220,7 +220,7 @@ async def test_ecomax_setup_errors(mock_wait_for, mock_request, ecomax: EcoMAX)
     await ecomax.wait_until_done()
     assert FrameType.REQUEST_ALERTS in ecomax.get_nowait(ATTR_FRAME_ERRORS, [])
     assert mock_request.await_count == len(REQUIRED)
-    mock_wait_for.assert_awaited_once_with(ATTR_SENSORS)
+    mock_wait_for.assert_awaited_once_with(ATTR_SENSORS, timeout=30.0)
 
 
 @patch("asyncio.Queue.put")

{pyplumio-0.5.52 → pyplumio-0.5.54}/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.54}/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)