PyPlumIO 0.5.19__py3-none-any.whl → 0.5.20__py3-none-any.whl

{PyPlumIO-0.5.19.dist-info → PyPlumIO-0.5.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.5.19
+Version: 0.5.20
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -38,7 +38,7 @@ Requires-Dist: mypy ==1.10.0 ; extra == 'test'
 Requires-Dist: pyserial-asyncio-fast ==0.11 ; extra == 'test'
 Requires-Dist: pytest ==8.2.1 ; extra == 'test'
 Requires-Dist: pytest-asyncio ==0.23.7 ; extra == 'test'
-Requires-Dist: ruff ==0.4.5 ; extra == 'test'
+Requires-Dist: ruff ==0.4.7 ; extra == 'test'
 Requires-Dist: tox ==4.15.0 ; extra == 'test'
 Requires-Dist: types-pyserial ==3.5.0.20240527 ; extra == 'test'
 

{PyPlumIO-0.5.19.dist-info → PyPlumIO-0.5.20.dist-info}/RECORD

@@ -1,15 +1,15 @@
 pyplumio/__init__.py,sha256=cclyAwy7OsW673iHcwkVrJSNnf32oF51Y_0uEEF5cdI,3293
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=aaNQTfdqRF8htFsemknyCzmnRLGw2JWETdmpWppxxVQ,413
-pyplumio/connection.py,sha256=IFSIUyMj8YkXW7TFP23nNGjs8QoZafgCPYmxaQpvads,6200
+pyplumio/_version.py,sha256=eONbmd59kUJvI6efSg_Cy7fvmhvKc1Uota8ebahOmE0,413
+pyplumio/connection.py,sha256=ZZHXHFpbOBVd9DGZV_H8lpdYtYoc3nP9fRolKATKDnQ,6096
 pyplumio/const.py,sha256=8rpiVbVb5R_6Rm6J2sgCnaVrkD-2Fzhd1RYMz0MBgwo,3915
 pyplumio/exceptions.py,sha256=193z3zfnswYhIYPzCIpxCiWat4qI3cV85sqT4YOSo-4,699
 pyplumio/filters.py,sha256=bIonYc_QbGMsL8aWweSLUmP7gKqDD646zELf_PqqQBg,11161
-pyplumio/protocol.py,sha256=y4JRN5hQVtxMt_y0XwqdSVd_tK_vzPgW8Zje-UunyW0,8184
+pyplumio/protocol.py,sha256=i4C7WYALp6BEHzeMjiebH8GWI2qGIEPk6OlUIx_2UP4,7870
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=lKffNkI__oK3kS3_K0m4nyINm_7-sSv7xbu3xleyhJg,4486
+pyplumio/stream.py,sha256=DqMqdi3HG9hODgfGo4eTKLkfoaSh5RS4kBHNn3ODvVg,4472
 pyplumio/utils.py,sha256=GV7P1hPLoQsx3uqYviQ15FXJmkmTxwtDibAc-yRarvo,688
-pyplumio/devices/__init__.py,sha256=MXNPnIcIykE6zrqh9yaP7vjMf_ysyrHauDerDNkInNQ,6502
+pyplumio/devices/__init__.py,sha256=O5SyEt_x1nJ1JYkG6v3dTZ54tu9sKIdj4l256JhvLHg,6585
 pyplumio/devices/ecomax.py,sha256=W9YW4nw6v2wdKKqFblUx03_hFJw0dVjnVkDHNL8P2dg,16632
 pyplumio/devices/ecoster.py,sha256=J4YtPmFmFwaq4LzYf28aMmB97cRAbMsVyUdBLGki42g,313
 pyplumio/devices/mixer.py,sha256=PGk0lXveN6q5sm0B50YG0yCVYoKi1a9TA3v44bGgi3A,2947
@@ -20,12 +20,12 @@ pyplumio/frames/requests.py,sha256=Ra8xH5oKYhkEUtadN-9ZsJKkt5xZkz5O7edQVsDhNsM,7
 pyplumio/frames/responses.py,sha256=j4awA2-MfsoPdENC4Fvae4_Oa70rDhH19ebmEoAqhh8,6532
 pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
 pyplumio/helpers/data_types.py,sha256=H_pYkLgIu30lDFU0UUZ1V3vYxa9A_-1nhiJu-HCLuoc,8212
-pyplumio/helpers/event_manager.py,sha256=EJLNykwgTSl_RRE2ulGny3Matr_FSi73rKrdLXIX6ss,6005
+pyplumio/helpers/event_manager.py,sha256=eSaqFGwED_UlugDwGRusfpivolqV6TISs1XnzBH6e60,5863
 pyplumio/helpers/factory.py,sha256=eiTkYUCernUn0VNDDdEN4IyjNPrXK8vnJESXyLaqFzE,1017
 pyplumio/helpers/parameter.py,sha256=gYCA2SLU_lbdtQZq5U64yzpyLoEIa0R1wyJJGmgL63I,8699
 pyplumio/helpers/schedule.py,sha256=-IZJ-CU4PhFlsE586wTw--ovDrTo2Hs4JneCHhc0e-Y,5013
 pyplumio/helpers/task_manager.py,sha256=RpdYSguc0cap_Onf9VnL-yCd_KwR2JPD49trZCRKPpI,1090
-pyplumio/helpers/timeout.py,sha256=ou_pgExP5HqhrOdqEiqadVnRnelPd-N69VIIrDVq-aA,1287
+pyplumio/helpers/timeout.py,sha256=k-829fBcHT5IR3isrMSgNbPYK-ubeY1BAwndCDIiX9E,824
 pyplumio/helpers/typing.py,sha256=y55UdpIpPIRuUBPgfPmZHAwPdIUjQO924-kO7AVXhes,685
 pyplumio/helpers/uid.py,sha256=yaBjcsFKuhOaznftk33kdIepQHpK-labEQr59QNKhPM,975
 pyplumio/structures/__init__.py,sha256=EjK-5qJZ0F7lpP2b6epvTMg9cIBl4Kn91nqNkEcLwTc,1299
@@ -54,8 +54,8 @@ pyplumio/structures/statuses.py,sha256=wkoynyMRr1VREwfBC6vU48kPA8ZQ83pcXuciy2xHJ
 pyplumio/structures/temperatures.py,sha256=1CDzehNmbALz1Jyt_9gZNIk52q6Wv-xQXjijVDCVYec,2337
 pyplumio/structures/thermostat_parameters.py,sha256=pjbWsT6z7mlDiUrC5MWGqMtGP0deeVMYeeTa7yGEwJ8,7706
 pyplumio/structures/thermostat_sensors.py,sha256=ZmjWgYtTZ5M8Lnz_Q5N4JD8G3MvEmByPFjYsy6XZOmo,3177
-PyPlumIO-0.5.19.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-PyPlumIO-0.5.19.dist-info/METADATA,sha256=7Vbk_OIL0hieiiT0U5LFjYi7dAJkzwAXrxeVnZmG_-A,5415
-PyPlumIO-0.5.19.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-PyPlumIO-0.5.19.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-PyPlumIO-0.5.19.dist-info/RECORD,,
+PyPlumIO-0.5.20.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+PyPlumIO-0.5.20.dist-info/METADATA,sha256=nTyxUOv5kPz-K5xNnm389H-eFlLN48mXYMmc3E4zHQ0,5415
+PyPlumIO-0.5.20.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+PyPlumIO-0.5.20.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.20.dist-info/RECORD,,

pyplumio/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.19'
-__version_tuple__ = version_tuple = (0, 5, 19)
+__version__ = version = '0.5.20'
+__version_tuple__ = version_tuple = (0, 5, 20)

pyplumio/connection.py

@@ -72,10 +72,7 @@ class Connection(ABC, TaskManager):
     async def _connect(self) -> None:
         """Establish connection and initialize the protocol object."""
         try:
-            reader, writer = cast(
-                tuple[asyncio.StreamReader, asyncio.StreamWriter],
-                await self._open_connection(),
-            )
+            reader, writer = await self._open_connection()
             self.protocol.connection_established(reader, writer)
         except (OSError, SerialException, asyncio.TimeoutError) as err:
             raise ConnectionFailedError from err

pyplumio/devices/__init__.py

@@ -111,6 +111,11 @@ class Device(ABC, EventManager):
         """
         self.create_task(self.set(name, value, timeout, retries))
 
+    async def shutdown(self) -> None:
+        """Cancel device tasks."""
+        self.cancel_tasks()
+        await self.wait_until_done()
+
 
 class AddressableDevice(Device, ABC):
     """Represents an addressable device."""
@@ -139,9 +144,7 @@ class AddressableDevice(Device, ABC):
         """Set up addressable device."""
         results = await asyncio.gather(
             *{
-                self.create_task(
-                    self.request(description.provides, description.frame_type)
-                )
+                self.request(description.provides, description.frame_type)
                 for description in self._setup_frames
             },
             return_exceptions=True,

pyplumio/helpers/event_manager.py

@@ -165,11 +165,6 @@ class EventManager(TaskManager):
             if not event.is_set():
                 event.set()
 
-    async def shutdown(self) -> None:
-        """Cancel scheduled tasks."""
-        self.cancel_tasks()
-        await self.wait_until_done()
-
     @property
     def events(self) -> dict[str, asyncio.Event]:
         """Return the events."""

pyplumio/helpers/timeout.py

@@ -17,30 +17,16 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def timeout(
-    seconds: int, raise_exception: bool = True
-) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Coroutine[Any, Any, T | None]]]:
-    """Decorate a timeout for the awaitable.
-
-    Return None on exception if raise_exception parameter is set to false.
-    """
+    seconds: int,
+) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Coroutine[Any, Any, T]]]:
+    """Decorate a timeout for the awaitable."""
 
     def decorator(
         func: Callable[P, Awaitable[T]],
-    ) -> Callable[P, Coroutine[Any, Any, T | None]]:
+    ) -> Callable[P, Coroutine[Any, Any, T]]:
         @wraps(func)
-        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
-            try:
-                return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
-            except asyncio.TimeoutError:
-                if raise_exception:
-                    raise
-
-                _LOGGER.warning(
-                    "Function '%s' timed out after %i seconds",
-                    func.__name__,
-                    seconds,
-                )
-                return None
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
 
         return wrapper
 

pyplumio/protocol.py

@@ -5,17 +5,12 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import asyncio
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 import logging
-from typing import NamedTuple, cast
 
 from pyplumio.const import ATTR_CONNECTED, DeviceType
 from pyplumio.devices import AddressableDevice
-from pyplumio.exceptions import (
-    FrameDataError,
-    FrameError,
-    ReadError,
-    UnknownDeviceError,
-)
+from pyplumio.exceptions import FrameError, ReadError, UnknownDeviceError
 from pyplumio.frames import Frame
 from pyplumio.frames.requests import StartMasterRequest
 from pyplumio.helpers.event_manager import EventManager
@@ -101,12 +96,20 @@ class DummyProtocol(Protocol):
             await self.close_writer()
 
 
-class Queues(NamedTuple):
+@dataclass
+class Queues:
     """Represents asyncio queues."""
 
+    __slots__ = ("read", "write")
+
     read: asyncio.Queue
     write: asyncio.Queue
 
+    async def join(self) -> None:
+        """Wait for queues to finish."""
+        for queue in (self.read, self.write):
+            await queue.join()
+
 
 class AsyncProtocol(Protocol, EventManager):
     """Represents an async protocol.
@@ -117,11 +120,11 @@ class AsyncProtocol(Protocol, EventManager):
     The frame producer tries to read frames from the write queue.
     If any is available, it sends them to the device via frame writer.
 
-    It then reads stream via frame reader, creates device entry and puts
-    received frame into the read queue.
+    It then reads stream via frame reader and puts received frame
+    into the read queue.
 
-    Frame consumers read frames from the read queue and send frame to
-    their respective device class for further processing.
+    Frame consumers read frames from the read queue, create device
+    entry, if needed, and send frame to the entry for the processing.
     """
 
     consumers_count: int
@@ -139,18 +142,10 @@ class AsyncProtocol(Protocol, EventManager):
         super().__init__()
         self.consumers_count = consumers_count
         self._network = NetworkInfo(
-            eth=(
-                EthernetParameters(status=False)
-                if ethernet_parameters is None
-                else ethernet_parameters
-            ),
-            wlan=(
-                WirelessParameters(status=False)
-                if wireless_parameters is None
-                else wireless_parameters
-            ),
+            eth=ethernet_parameters or EthernetParameters(status=False),
+            wlan=wireless_parameters or WirelessParameters(status=False),
         )
-        self._queues = Queues(asyncio.Queue(), asyncio.Queue())
+        self._queues = Queues(read=asyncio.Queue(), write=asyncio.Queue())
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -159,7 +154,9 @@ class AsyncProtocol(Protocol, EventManager):
         self.reader = FrameReader(reader)
         self.writer = FrameWriter(writer)
         self._queues.write.put_nowait(StartMasterRequest(recipient=DeviceType.ECOMAX))
-        self.create_task(self.frame_producer(self._queues))
+        self.create_task(
+            self.frame_producer(self._queues, reader=self.reader, writer=self.writer)
+        )
         for _ in range(self.consumers_count):
             self.create_task(self.frame_consumer(self._queues.read))
 
@@ -184,8 +181,9 @@ class AsyncProtocol(Protocol, EventManager):
 
     async def shutdown(self) -> None:
         """Shutdown protocol tasks."""
-        await asyncio.gather(*[queue.join() for queue in self._queues])
-        await super(Protocol, self).shutdown()
+        await self._queues.join()
+        self.cancel_tasks()
+        await self.wait_until_done()
         for device in self.data.values():
             await device.shutdown()
 
@@ -193,33 +191,27 @@ class AsyncProtocol(Protocol, EventManager):
             self.connected.clear()
             await self.close_writer()
 
-    async def frame_producer(self, queues: Queues) -> None:
+    async def frame_producer(
+        self, queues: Queues, reader: FrameReader, writer: FrameWriter
+    ) -> None:
         """Handle frame reads and writes."""
         await self.connected.wait()
-        reader = cast(FrameReader, self.reader)
-        writer = cast(FrameWriter, self.writer)
         while self.connected.is_set():
             try:
-                if queues.write.qsize() > 0:
+                if not queues.write.empty():
                     await writer.write(await queues.write.get())
                     queues.write.task_done()
 
                 if (response := await reader.read()) is not None:
                     queues.read.put_nowait(response)
 
-            except FrameDataError as e:
-                _LOGGER.warning("Incorrect payload: %s", e)
-            except ReadError as e:
-                _LOGGER.debug("Read error: %s", e)
-            except UnknownDeviceError as e:
-                _LOGGER.debug("Unknown device: %s", e)
-            except FrameError as e:
+            except (ReadError, UnknownDeviceError, FrameError) as e:
                 _LOGGER.debug("Can't process received frame: %s", e)
             except (OSError, asyncio.TimeoutError):
                 self.create_task(self.connection_lost())
                 break
-            except Exception as e:  # pylint: disable=broad-except
-                _LOGGER.exception(e)
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
 
     async def frame_consumer(self, queue: asyncio.Queue) -> None:
         """Handle frame processing."""

pyplumio/stream.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 from asyncio import IncompleteReadError, StreamReader, StreamWriter
 import logging
-from typing import Final
+from typing import Final, NamedTuple
 
 from pyplumio.const import DeviceType
 from pyplumio.devices import is_known_device_type
@@ -54,6 +54,18 @@ class FrameWriter:
         await self._writer.wait_closed()
 
 
+class Header(NamedTuple):
+    """Represents a frame header."""
+
+    bytes: bytes
+    frame_start: int
+    frame_length: int
+    recipient: int
+    sender: int
+    econet_type: int
+    econet_version: int
+
+
 class FrameReader:
     """Represents a frame reader."""
 
@@ -65,11 +77,11 @@ class FrameReader:
         """Initialize a new frame reader."""
         self._reader = reader
 
-    async def _read_header(self) -> tuple[bytes, int, int, int, int, int]:
+    async def _read_header(self) -> Header:
         """Locate and read a frame header.
 
         Raise pyplumio.ReadError if header size is too small and
-        OSError on broken connection.
+        OSError if serial connection is broken.
         """
         while buffer := await self._reader.read(1):
             if FRAME_START not in buffer:
@@ -79,23 +91,7 @@ class FrameReader:
             if len(buffer) < struct_header.size:
                 raise ReadError(f"Header can't be less than {struct_header.size} bytes")
 
-            [
-                _,
-                length,
-                recipient,
-                sender,
-                econet_type,
-                econet_version,
-            ] = struct_header.unpack_from(buffer)
-
-            return (
-                buffer,
-                length,
-                recipient,
-                sender,
-                econet_type,
-                econet_version,
-            )
+            return Header(buffer, *struct_header.unpack_from(buffer))
 
         raise OSError("Serial connection broken")
 
@@ -108,8 +104,9 @@ class FrameReader:
         checksum.
         """
         (
-            header,
-            length,
+            header_bytes,
+            _,
+            frame_length,
             recipient,
             sender,
             econet_type,
@@ -122,19 +119,21 @@ class FrameReader:
         if not is_known_device_type(sender):
             raise UnknownDeviceError(f"Unknown sender type ({sender})")
 
-        if length > MAX_FRAME_LENGTH or length < MIN_FRAME_LENGTH:
-            raise ReadError(f"Unexpected frame length ({length})")
+        if frame_length > MAX_FRAME_LENGTH or frame_length < MIN_FRAME_LENGTH:
+            raise ReadError(f"Unexpected frame length ({frame_length})")
 
         try:
-            payload = await self._reader.readexactly(length - struct_header.size)
+            payload = await self._reader.readexactly(frame_length - struct_header.size)
         except IncompleteReadError as e:
             raise ReadError(
                 "Got an incomplete frame while trying to read "
-                + f"'{length - struct_header.size}' bytes"
+                + f"'{frame_length - struct_header.size}' bytes"
             ) from e
 
-        if payload[-2] != bcc(header + payload[:-2]):
-            raise ChecksumError(f"Incorrect frame checksum ({payload[-2]})")
+        if (checksum := bcc(header_bytes + payload[:-2])) and checksum != payload[-2]:
+            raise ChecksumError(
+                f"Incorrect frame checksum ({checksum} != {payload[-2]})"
+            )
 
         frame = await Frame.create(
             frame_type=payload[0],