PyPlumIO 0.5.52__py3-none-any.whl → 0.5.53__py3-none-any.whl

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/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/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/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/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/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/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/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.dist-info → pyplumio-0.5.53.dist-info}/METADATA

@@ -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.dist-info → pyplumio-0.5.53.dist-info}/RECORD

@@ -1,21 +1,21 @@
 pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=yGNU5eJ0S_ns8vdsPIX0Yq-JAj22V0bb0R9aJSWHpgE,513
-pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
+pyplumio/_version.py,sha256=XU3GvfwHGD0uhY3L2CgqZXptcJXNuiDPHBlo4yPL1hY,513
+pyplumio/connection.py,sha256=u-iOzEUqoEEL4YLpLtzBWi5Qy8_RABgKD8DyXf-er-4,5892
 pyplumio/const.py,sha256=eoq-WNJ8TO3YlP7dC7KkVQRKGjt9FbRZ6M__s29vb1U,5659
-pyplumio/data_types.py,sha256=r-QOIZiIpBFo4kRongyu8n0BHTaEU6wWMTmNkWBNjq8,9223
+pyplumio/data_types.py,sha256=BTDxwErRo_odvFT5DNfIniNh8ZfyjRKEDaJmoEJqdEg,9426
 pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
-pyplumio/filters.py,sha256=8IPDa8GQLKf4OdoLwlTxFyffvZXt-VrE6nKpttMVTLg,15400
+pyplumio/filters.py,sha256=gW3XadVYIMunpHmVQRLc_dAqTldKZl8yvGjTTIWNKXc,15607
 pyplumio/protocol.py,sha256=DWM-yJnm2EQPLvGzXNlkQ0IpKQn44e-WkNB_DqZAag8,8313
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=XzDZ1mkwUwy8wHtVII2W9t_8NpCQEwFmnlMeHwh8cd0,7832
-pyplumio/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
+pyplumio/stream.py,sha256=zFMKZ_GxsSGcaBTJigVM1CK3uGjlEJXgcvKqus8MDzk,7740
+pyplumio/utils.py,sha256=ktV8_Th2DiwQ0W6afOCau9kBJ8pOrqR-SM2Y2GRy-xE,1869
 pyplumio/devices/__init__.py,sha256=OLPY_Kk5E2SiJ4FLN2g6zmKQdQfutePV5jRH9kRHAMA,8260
 pyplumio/devices/ecomax.py,sha256=3_Hk6RaQ2e9WqIJ2NdPhofgVFjLbWIyR3TsRmMG35WY,16043
 pyplumio/devices/ecoster.py,sha256=X46ky5XT8jHMFq9sBW0ve8ZI_tjItQDMt4moXsW-ogY,307
 pyplumio/devices/mixer.py,sha256=7WdUVgwO4VXmaPNzh3ZWpKr2ooRXWemz2KFHAw35_Rk,2731
 pyplumio/devices/thermostat.py,sha256=MHMKe45fQ7jKlhBVObJ7McbYQKuF6-LOKSHy-9VNsCU,2253
-pyplumio/frames/__init__.py,sha256=iHydFDClh3EDjElBis6nicNmF0QnahguBEtY_HOHsck,7885
+pyplumio/frames/__init__.py,sha256=QAjdvZxQj5Av1OKFqdlSgZBn3RbCcRVMQv_lCnTkW5M,8272
 pyplumio/frames/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
 pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
 pyplumio/frames/responses.py,sha256=M6Ky4gg2AoShmRXX0x6nftajxrvmQLKPVRWbwyhvI0E,6663
@@ -24,8 +24,7 @@ pyplumio/helpers/async_cache.py,sha256=EGQcU8LWJpVx3Hk6iaI-3mqAhnR5ACfBOGb9tWw-V
 pyplumio/helpers/event_manager.py,sha256=aKNlhsPNTy3eOSfWVb9TJxtIsN9GAQv9XxhOi_BOhlM,8097
 pyplumio/helpers/factory.py,sha256=c3sitnkUjJWz7fPpTE9uRIpa8h46Qim3xsAblMw3eDo,1049
 pyplumio/helpers/task_manager.py,sha256=N71F6Ag1HHxdf5zJeCMcEziFdH9lmJKtMPoRGjJ-E40,1209
-pyplumio/helpers/timeout.py,sha256=2wAcOug-2TgdCchKbfv0VhAfNzP-MPM0TEFtRNFJ_m8,803
-pyplumio/parameters/__init__.py,sha256=2YTJJF-ehMLbPJwp02I1fycyLsatIXPSlTxXLwtkHtk,16054
+pyplumio/parameters/__init__.py,sha256=YKIXmb_-E2HeIVljDHdD2bLbsfUsQ8sVhl9sl7kLzyo,16220
 pyplumio/parameters/ecomax.py,sha256=4UqI7cokCt7qS9Du4-7JgLhM7mhHCHt8SWPl_qncmXQ,26239
 pyplumio/parameters/mixer.py,sha256=RjhfUU_62STyNV0Ud9A4G4FEvVwo02qGVl8h1QvqQXI,6646
 pyplumio/parameters/thermostat.py,sha256=-DK2Mb78CGrKmdhwAD0M3GiGJatczPnl1e2gVeT19tI,5070
@@ -57,8 +56,8 @@ pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8p
 pyplumio/structures/temperatures.py,sha256=2VD3P_vwp9PEBkOn2-WhifOR8w-UYNq35aAxle0z2Vg,2831
 pyplumio/structures/thermostat_parameters.py,sha256=st3x3HkjQm3hqBrn_fpvPDQu8fuc-Sx33ONB19ViQak,3007
 pyplumio/structures/thermostat_sensors.py,sha256=rO9jTZWGQpThtJqVdbbv8sYMYHxJi4MfwZQza69L2zw,3399
-pyplumio-0.5.52.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.52.dist-info/METADATA,sha256=FMrf9h1q6n2yj7eafOP4MxGkRwTPEw3a0rMDi_xvyh4,5611
-pyplumio-0.5.52.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyplumio-0.5.52.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.52.dist-info/RECORD,,
+pyplumio-0.5.53.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.53.dist-info/METADATA,sha256=GxKUdJNkna132kU5kPYV8_piH9cqw34mVUnflq1L1Rc,5615
+pyplumio-0.5.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyplumio-0.5.53.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.53.dist-info/RECORD,,

pyplumio/helpers/timeout.py

@@ -1,32 +0,0 @@
-"""Contains a timeout decorator."""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Awaitable, Callable
-from functools import wraps
-from typing import TypeVar
-
-from typing_extensions import ParamSpec
-
-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__ = ["timeout"]