PyPlumIO 0.5.51__py3-none-any.whl → 0.5.52__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.51'
-__version_tuple__ = version_tuple = (0, 5, 51)
+__version__ = version = '0.5.52'
+__version_tuple__ = version_tuple = (0, 5, 52)

pyplumio/frames/__init__.py

@@ -15,10 +15,14 @@ from pyplumio.utils import ensure_dict, to_camelcase
 
 FRAME_START: Final = 0x68
 FRAME_END: Final = 0x16
-HEADER_OFFSET: Final = 0
+
+
+HEADER_INDEX: Final = 0
 FRAME_TYPE_SIZE: Final = 1
-CRC_SIZE: Final = 1
+BCC_SIZE: Final = 1
+BCC_INDEX: Final = -2
 DELIMITER_SIZE: Final = 1
+
 ECONET_TYPE: Final = 48
 ECONET_VERSION: Final = 5
 
@@ -199,7 +203,7 @@ class Frame(ABC):
             struct_header.size
             + FRAME_TYPE_SIZE
             + len(self.message)
-            + CRC_SIZE
+            + BCC_SIZE
             + DELIMITER_SIZE
         )
 
@@ -209,7 +213,7 @@ class Frame(ABC):
         buffer = bytearray(struct_header.size)
         struct_header.pack_into(
             buffer,
-            HEADER_OFFSET,
+            HEADER_INDEX,
             FRAME_START,
             self.length,
             int(self.recipient),

pyplumio/stream.py

@@ -5,14 +5,16 @@ from __future__ import annotations
 import asyncio
 from asyncio import IncompleteReadError, StreamReader, StreamWriter
 import logging
-from typing import Final, NamedTuple
+from typing import Final, NamedTuple, SupportsIndex
 
 from pyplumio.const import DeviceType
 from pyplumio.devices import is_known_device_type
 from pyplumio.exceptions import ChecksumError, ReadError, UnknownDeviceError
 from pyplumio.frames import (
+    BCC_INDEX,
     DELIMITER_SIZE,
     FRAME_START,
+    FRAME_TYPE_SIZE,
     HEADER_SIZE,
     Frame,
     bcc,
@@ -26,6 +28,8 @@ WRITER_TIMEOUT: Final = 10
 MIN_FRAME_LENGTH: Final = 10
 MAX_FRAME_LENGTH: Final = 1000
 
+DEFAULT_BUFFER_SIZE: Final = 5000
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -63,6 +67,103 @@ class FrameWriter:
         await self._writer.wait_closed()
 
 
+class BufferManager:
+    """Represents a buffered reader for reading frames."""
+
+    __slots__ = ("_buffer", "_reader")
+
+    _buffer: bytearray
+    _reader: StreamReader
+
+    def __init__(self, reader: StreamReader) -> None:
+        """Initialize a new buffered reader."""
+        self._buffer = bytearray()
+        self._reader = reader
+
+    async def ensure_buffer(self, size: int) -> None:
+        """Ensure the internal buffer size."""
+        bytes_to_read = size - len(self._buffer)
+        if bytes_to_read <= 0:
+            return None
+
+        try:
+            data = await self._reader.readexactly(bytes_to_read)
+            self._buffer.extend(data)
+            self.trim_to(size)
+        except IncompleteReadError as e:
+            raise ReadError(
+                f"Incomplete read. Tried to read {bytes_to_read} additional bytes "
+                f"to reach a total of {size}, but only {len(e.partial)} bytes were "
+                "available from stream."
+            ) from e
+        except asyncio.CancelledError:
+            _LOGGER.debug("Read operation cancelled while ensuring buffer")
+            raise
+        except Exception as e:
+            raise OSError(
+                f"Serial connection broken while trying to ensure {size} bytes: {e}"
+            ) from e
+
+    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."""
+        try:
+            return await self.peek(size)
+        finally:
+            await self.consume(size)
+
+    def seek_to(self, delimiter: SupportsIndex) -> bool:
+        """Trim the buffer to the first occurrence of the delimiter.
+
+        Returns True if the delimiter was found and trimmed, False otherwise.
+        """
+        if not self._buffer or (index := self._buffer.find(delimiter)) == -1:
+            return False
+
+        self._buffer = self._buffer[index:]
+        return True
+
+    def trim_to(self, size: int) -> None:
+        """Trim buffer to size."""
+        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."""
+        return self._buffer
+
+
 class Header(NamedTuple):
     """Represents a frame header."""
 
@@ -76,81 +177,65 @@ class Header(NamedTuple):
 class FrameReader:
     """Represents a frame reader."""
 
-    __slots__ = ("_reader",)
+    __slots__ = ("_buffer",)
 
-    _reader: StreamReader
+    _buffer: BufferManager
 
     def __init__(self, reader: StreamReader) -> None:
         """Initialize a new frame reader."""
-        self._reader = reader
-
-    async def _read_header(self) -> tuple[Header, bytes]:
-        """Locate and read a frame header.
-
-        Raise pyplumio.ReadError if header size is too small and
-        OSError if serial connection is broken.
-        """
-        while buffer := await self._reader.read(DELIMITER_SIZE):
-            if FRAME_START not in buffer:
-                continue
-
-            try:
-                buffer += await self._reader.readexactly(HEADER_SIZE - DELIMITER_SIZE)
-            except IncompleteReadError as e:
-                raise ReadError(
-                    f"Incomplete header, expected {e.expected} bytes"
-                ) from e
+        self._buffer = BufferManager(reader)
 
-            return Header(*struct_header.unpack_from(buffer)[DELIMITER_SIZE:]), buffer
+    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:])
 
-        raise OSError("Serial connection broken")
+            await self._buffer.fill()
 
     @timeout(READER_TIMEOUT)
     async def read(self) -> Frame | None:
-        """Read the frame and return corresponding handler object.
-
-        Raise pyplumio.UnknownDeviceError when sender device has an
-        unknown address, raise pyplumio.ReadError on unexpected frame
-        length or incomplete frame, raise pyplumio.ChecksumError on
-        incorrect frame checksum.
-        """
-        header, buffer = await self._read_header()
+        """Read the frame and return corresponding handler object."""
+        header = await self._read_header()
         frame_length, recipient, sender, econet_type, econet_version = header
 
-        if recipient not in (DeviceType.ECONET, DeviceType.ALL):
-            # Not an intended recipient, ignore the frame.
-            return None
-
-        if not is_known_device_type(sender):
-            raise UnknownDeviceError(f"Unknown sender type ({sender})")
-
         if frame_length > MAX_FRAME_LENGTH or frame_length < MIN_FRAME_LENGTH:
+            await self._buffer.consume(HEADER_SIZE)
             raise ReadError(
                 f"Unexpected frame length ({frame_length}), expected between "
                 f"{MIN_FRAME_LENGTH} and {MAX_FRAME_LENGTH}"
             )
 
-        try:
-            buffer += await self._reader.readexactly(frame_length - HEADER_SIZE)
-        except IncompleteReadError as e:
-            raise ReadError(f"Incomplete frame, expected {e.expected} bytes") from e
-
-        if (checksum := bcc(buffer[:-2])) and checksum != buffer[-2]:
+        frame_bytes = await self._buffer.peek(frame_length)
+        checksum = bcc(frame_bytes[:BCC_INDEX])
+        if checksum != frame_bytes[BCC_INDEX]:
+            await self._buffer.consume(HEADER_SIZE)
             raise ChecksumError(
                 f"Incorrect frame checksum: calculated {checksum}, "
-                f"expected {buffer[-2]}. "
-                f"Frame data: {buffer.hex()}"
+                f"expected {frame_bytes[BCC_INDEX]}. Frame data: {frame_bytes.hex()}"
+            )
+
+        await self._buffer.consume(frame_length)
+        if recipient not in (DeviceType.ECONET, DeviceType.ALL):
+            _LOGGER.debug(
+                "Skipping frame intended for different recipient (%s)", recipient
             )
+            return None
+
+        if not is_known_device_type(sender):
+            raise UnknownDeviceError(f"Unknown sender type ({sender})")
 
+        payload_bytes = frame_bytes[HEADER_SIZE:BCC_INDEX]
         frame = await Frame.create(
-            frame_type=buffer[HEADER_SIZE],
+            frame_type=payload_bytes[0],
             recipient=DeviceType(recipient),
             sender=DeviceType(sender),
             econet_type=econet_type,
             econet_version=econet_version,
-            message=buffer[HEADER_SIZE + 1 : -2],
+            message=payload_bytes[FRAME_TYPE_SIZE:],
         )
-        _LOGGER.debug("Received frame: %s, bytes: %s", frame, buffer.hex())
+        _LOGGER.debug("Received frame: %s, bytes: %s", frame, frame_bytes.hex())
 
         return frame
 

pyplumio/structures/alerts.py

@@ -121,4 +121,4 @@ class AlertsStructure(StructureDecoder):
         )
 
 
-__all__ = ["AlertsStructure", "Alert"]
+__all__ = ["AlertsStructure", "Alert", "ATTR_ALERTS", "ATTR_TOTAL_ALERTS"]

pyplumio/structures/schedules.py

@@ -175,7 +175,7 @@ def get_time(
 ) -> Time:
     """Return time for a specific index."""
     time_dt = start + (step * index)
-    return time_dt.strftime(TIME_FORMAT)
+    return f"{time_dt.hour:02d}:{time_dt.minute:02d}"
 
 
 @lru_cache(maxsize=10)

{pyplumio-0.5.51.dist-info → pyplumio-0.5.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.51
+Version: 0.5.52
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,17 +25,17 @@ 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.13.2
+Requires-Dist: typing-extensions==4.14.0
 Provides-Extra: test
 Requires-Dist: codespell==2.4.1; extra == "test"
-Requires-Dist: coverage==7.8.0; extra == "test"
-Requires-Dist: freezegun==1.5.1; extra == "test"
-Requires-Dist: mypy==1.15.0; 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: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
-Requires-Dist: pytest==8.3.5; extra == "test"
-Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
-Requires-Dist: ruff==0.11.10; 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"
 Provides-Extra: docs

{pyplumio-0.5.51.dist-info → pyplumio-0.5.52.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=GxxIjlMXqyiJ35TfmryleP4-ULoCRkGKYVM-gOVMu_0,513
+pyplumio/_version.py,sha256=yGNU5eJ0S_ns8vdsPIX0Yq-JAj22V0bb0R9aJSWHpgE,513
 pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
 pyplumio/const.py,sha256=eoq-WNJ8TO3YlP7dC7KkVQRKGjt9FbRZ6M__s29vb1U,5659
 pyplumio/data_types.py,sha256=r-QOIZiIpBFo4kRongyu8n0BHTaEU6wWMTmNkWBNjq8,9223
@@ -8,14 +8,14 @@ pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
 pyplumio/filters.py,sha256=8IPDa8GQLKf4OdoLwlTxFyffvZXt-VrE6nKpttMVTLg,15400
 pyplumio/protocol.py,sha256=DWM-yJnm2EQPLvGzXNlkQ0IpKQn44e-WkNB_DqZAag8,8313
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=iCB-XlNXRRE0p7nstb1AkXwVDwcCsgym_ggB_IDiJc8,4926
+pyplumio/stream.py,sha256=XzDZ1mkwUwy8wHtVII2W9t_8NpCQEwFmnlMeHwh8cd0,7832
 pyplumio/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
 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=5lw19oFlN89ZvO8KGwnkwERULQNYiP-hhZKk65LsjYY,7862
+pyplumio/frames/__init__.py,sha256=iHydFDClh3EDjElBis6nicNmF0QnahguBEtY_HOHsck,7885
 pyplumio/frames/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
 pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
 pyplumio/frames/responses.py,sha256=M6Ky4gg2AoShmRXX0x6nftajxrvmQLKPVRWbwyhvI0E,6663
@@ -32,7 +32,7 @@ pyplumio/parameters/thermostat.py,sha256=-DK2Mb78CGrKmdhwAD0M3GiGJatczPnl1e2gVeT
 pyplumio/parameters/custom/__init__.py,sha256=o1khThLf4FMrjErFIcikAc6jI9gn5IyZlo7LNKKqJG4,3194
 pyplumio/parameters/custom/ecomax_860d3_hb.py,sha256=IsNgDXmV90QpBilDV4fGSBtIUEQJJbR9rjnfCr3-pHE,2840
 pyplumio/structures/__init__.py,sha256=emZVH5OFgdTUPbEJoznMKitmK0nlPm0I4SmF86It1Do,1345
-pyplumio/structures/alerts.py,sha256=bhfFEICdwdNpIaP584cdDgfDA29s6knXMJAnu3tj_EQ,3688
+pyplumio/structures/alerts.py,sha256=Whl_WyHV9sXr321SuJAYBc1wUawNzi7xMZc41M8qToY,3724
 pyplumio/structures/boiler_load.py,sha256=e-6itp9L6iJeeOyhSTiOclHLuYmqG7KkcepsHwJSQSI,894
 pyplumio/structures/boiler_power.py,sha256=7CdOk-pYLEpy06oRBAeichvq8o-a2RcesB0tzo9ccBs,951
 pyplumio/structures/ecomax_parameters.py,sha256=E_s5bO0RqX8p1rM5DtYAsEXcHqS8P6Tg4AGm21cxsnM,1663
@@ -52,13 +52,13 @@ pyplumio/structures/product_info.py,sha256=Y5Q5UzKcxrixkB3Fd_BZaj1DdUNvUw1XASqR1
 pyplumio/structures/program_version.py,sha256=qHmmPComCOa-dgq7cFAucEGuRS-jWYwWi40VCiPS7cc,2621
 pyplumio/structures/regulator_data.py,sha256=SYKI1YPC3mDAth-SpYejttbD0IzBfobjgC-uy_uUKnw,2333
 pyplumio/structures/regulator_data_schema.py,sha256=0SapbZCGzqAHmHC7dwhufszJ9FNo_ZO_XMrFGNiUe-w,1547
-pyplumio/structures/schedules.py,sha256=po-LFc3-Na6Rz9786fjBd9Gy3EDC1h6FKEmIM927ky8,12039
+pyplumio/structures/schedules.py,sha256=SGD9p12G_BVU2PSR1k5AS1cgx_bujFw8rqKSFohtEbc,12052
 pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8pLI,1325
 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.51.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.51.dist-info/METADATA,sha256=X9tX4ay9diGk9nUkp-MhZIVc5Ldc6F1FbvSWDNE985k,5612
-pyplumio-0.5.51.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-pyplumio-0.5.51.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.51.dist-info/RECORD,,
+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.51.dist-info → pyplumio-0.5.52.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any