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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.5.19
+Version: 0.5.21
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -35,11 +35,11 @@ Provides-Extra: test
 Requires-Dist: codespell ==2.3.0 ; extra == 'test'
 Requires-Dist: coverage ==7.5.3 ; extra == 'test'
 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: pyserial-asyncio-fast ==0.12 ; extra == 'test'
+Requires-Dist: pytest ==8.2.2 ; extra == 'test'
 Requires-Dist: pytest-asyncio ==0.23.7 ; extra == 'test'
-Requires-Dist: ruff ==0.4.5 ; extra == 'test'
-Requires-Dist: tox ==4.15.0 ; extra == 'test'
+Requires-Dist: ruff ==0.4.9 ; extra == 'test'
+Requires-Dist: tox ==4.15.1 ; extra == 'test'
 Requires-Dist: types-pyserial ==3.5.0.20240527 ; extra == 'test'
 
 # PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.

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

@@ -1,38 +1,38 @@
 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=qwvYpiZ4pV_W2HOchGsudGTbl7hCvV-xhS0ii39Ac0I,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=Ci4p4bqADfWeGk9fzcGMudRbe-dFFa1UNot9no5Lj3M,7845
 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/ecomax.py,sha256=W9YW4nw6v2wdKKqFblUx03_hFJw0dVjnVkDHNL8P2dg,16632
+pyplumio/devices/__init__.py,sha256=O5SyEt_x1nJ1JYkG6v3dTZ54tu9sKIdj4l256JhvLHg,6585
+pyplumio/devices/ecomax.py,sha256=IPHyC8OjnGaQ_ZztcchgQjEJmNj8LfnP9sTJyslEQ14,16914
 pyplumio/devices/ecoster.py,sha256=J4YtPmFmFwaq4LzYf28aMmB97cRAbMsVyUdBLGki42g,313
-pyplumio/devices/mixer.py,sha256=PGk0lXveN6q5sm0B50YG0yCVYoKi1a9TA3v44bGgi3A,2947
-pyplumio/devices/thermostat.py,sha256=UR3KEkIBU-zx2LALvrt_QiFkiBT1CpKk7vYR1MSYdWY,2402
+pyplumio/devices/mixer.py,sha256=qJAmar7DdsQL1Syg0WOCBVQn3GyBTWEVyr5ZfpGytCk,2975
+pyplumio/devices/thermostat.py,sha256=HCnLVBX8mn6lmpCgl1DbDoCMI6T97sqmK-36cYcjXVA,2430
 pyplumio/frames/__init__.py,sha256=BAMbMHbn4F9psrf3sv0eJQA2Jd86qf7LQ5vBQY59gjA,7462
 pyplumio/frames/messages.py,sha256=QLuvo1wlpDZR1MpOdu7s6fRUX20Dtt6EWFLkAsqyax4,3617
 pyplumio/frames/requests.py,sha256=Ra8xH5oKYhkEUtadN-9ZsJKkt5xZkz5O7edQVsDhNsM,7221
 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=dCNLnSRZgewZ9Ppi-JtkxtvOmNd4ZejA7UT4oAT8FWM,5865
 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/task_manager.py,sha256=y5j7u31V6UE7g2ZhdsYsPykY-Awo73oWsNRUOrLSILg,1075
+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
 pyplumio/structures/alerts.py,sha256=a1CIf8vSEj5aefdqECIfCY5kV4tQ4kabMkp-_ixeWic,3260
 pyplumio/structures/boiler_load.py,sha256=p3mOzZUU-g7A2tG_yp8podEqpI81hlsOZmHELyPNRY8,838
 pyplumio/structures/boiler_power.py,sha256=72qsvccg49FdRdXv2f2K5sGpjT7wAOLFjlIGWpO-DVg,901
-pyplumio/structures/ecomax_parameters.py,sha256=07v97o9paqj_Ua9HkmEvwPgDT6a9btd8PKVSpVcTC4c,25835
+pyplumio/structures/ecomax_parameters.py,sha256=6HVEh4aNw0CGZD3CVQeYyKXQ0pzueQR_Tpm5fF3_0hA,25815
 pyplumio/structures/fan_power.py,sha256=Q5fv-7_2NVuLeQPIVIylvgN7M8-a9D8rRUE0QGjyS3w,871
 pyplumio/structures/frame_versions.py,sha256=x_OSirGYopQYgsRZIM3b1YlKHNIPmCbvAzhzO1wqy5k,1560
 pyplumio/structures/fuel_consumption.py,sha256=_p2dI4H67Eopn7IF0Gj77A8c_8lNKhhDDAtmugxLd4s,976
@@ -41,7 +41,7 @@ pyplumio/structures/lambda_sensor.py,sha256=6iUVyrPe6_QaGPo1lRzOfqorcTIIXRwnq3h8
 pyplumio/structures/mixer_parameters.py,sha256=ny7Ox94IooQd1ua22zGYkXLFaZQWGUYLEIM2_8vXk0U,8249
 pyplumio/structures/mixer_sensors.py,sha256=O91929Ts1YXFmKdPRc1r_BYDgrqkv5QVtE1nGzLpuAI,2260
 pyplumio/structures/modules.py,sha256=ukju4TQmRRJfgl94QU4zytZLU5px8nw3sgfSLn9JysU,2520
-pyplumio/structures/network_info.py,sha256=d1_MvG6n5f57ZEVZwSFFTXux0N07Gt1KnPDtlDfoMNQ,4055
+pyplumio/structures/network_info.py,sha256=ws2UdOhB89oKqmtW1Vsmfj0InRW4Sp6_kL1d4psk-8w,4094
 pyplumio/structures/output_flags.py,sha256=07N0kxlvR5WZAURuChk_BqSiXR8eaQrtI5qlkgCf4Yc,1345
 pyplumio/structures/outputs.py,sha256=1xsJPkjN643-aFawqVoupGatUIUJfQG_g252n051Qi0,1916
 pyplumio/structures/pending_alerts.py,sha256=Uq9WpB4MW9AhDkqmDhk-g0J0h4pVq0Q50z12dYEv6kY,739
@@ -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.21.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+PyPlumIO-0.5.21.dist-info/METADATA,sha256=mc-yvbFJArE1iYRxb8RCkL2MdoKZjkZKOn8nWgWD8t8,5415
+PyPlumIO-0.5.21.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+PyPlumIO-0.5.21.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.21.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.21'
+__version_tuple__ = version_tuple = (0, 5, 21)

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/devices/ecomax.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Generator, Iterable, Sequence
-from contextlib import suppress
 import logging
 import time
 from typing import Any, ClassVar, Final
@@ -18,7 +17,7 @@ from pyplumio.const import (
     DeviceType,
     FrameType,
 )
-from pyplumio.devices import AddressableDevice
+from pyplumio.devices import AddressableDevice, SubDevice
 from pyplumio.devices.mixer import Mixer
 from pyplumio.devices.thermostat import Thermostat
 from pyplumio.filters import on_change
@@ -263,8 +262,12 @@ class EcoMAX(AddressableDevice):
         if not parameters:
             return False
 
-        for mixer in self._mixers(parameters.keys()):
-            await mixer.dispatch(ATTR_MIXER_PARAMETERS, parameters[mixer.index])
+        await asyncio.gather(
+            *[
+                mixer.dispatch(ATTR_MIXER_PARAMETERS, parameters[mixer.index])
+                for mixer in self._mixers(indexes=parameters.keys())
+            ]
+        )
 
         return True
 
@@ -278,14 +281,18 @@ class EcoMAX(AddressableDevice):
         if not sensors:
             return False
 
-        for mixer in self._mixers(sensors.keys()):
-            await mixer.dispatch(ATTR_MIXER_SENSORS, sensors[mixer.index])
+        await asyncio.gather(
+            *[
+                mixer.dispatch(ATTR_MIXER_SENSORS, sensors[mixer.index])
+                for mixer in self._mixers(indexes=sensors.keys())
+            ]
+        )
 
         return True
 
     async def _add_schedules(
         self, schedules: list[tuple[int, list[list[bool]]]]
-    ) -> dict[str, Any]:
+    ) -> dict[str, Schedule]:
         """Add schedules to the dataset."""
         return {
             SCHEDULES[index]: Schedule(
@@ -333,8 +340,9 @@ class EcoMAX(AddressableDevice):
         For each sensor dispatch an event with the sensor's name and
         value.
         """
-        for name, value in sensors.items():
-            await self.dispatch(name, value)
+        await asyncio.gather(
+            *[self.dispatch(name, value) for name, value in sensors.items()]
+        )
 
         return True
 
@@ -371,10 +379,14 @@ class EcoMAX(AddressableDevice):
         if not parameters:
             return False
 
-        for thermostat in self._thermostats(parameters.keys()):
-            await thermostat.dispatch(
-                ATTR_THERMOSTAT_PARAMETERS, parameters[thermostat.index]
-            )
+        await asyncio.gather(
+            *[
+                thermostat.dispatch(
+                    ATTR_THERMOSTAT_PARAMETERS, parameters[thermostat.index]
+                )
+                for thermostat in self._thermostats(indexes=parameters.keys())
+            ]
+        )
 
         return True
 
@@ -401,10 +413,12 @@ class EcoMAX(AddressableDevice):
         if not sensors:
             return False
 
-        for thermostat in self._thermostats(sensors.keys()):
-            await thermostat.dispatch(
-                ATTR_THERMOSTAT_SENSORS, sensors[thermostat.index]
-            )
+        await asyncio.gather(
+            *[
+                thermostat.dispatch(ATTR_THERMOSTAT_SENSORS, sensors[thermostat.index])
+                for thermostat in self._thermostats(indexes=sensors.keys())
+            ]
+        )
 
         return True
 
@@ -438,10 +452,6 @@ class EcoMAX(AddressableDevice):
         """Shutdown tasks for the ecoMAX controller and sub-devices."""
         mixers = self.get_nowait(ATTR_MIXERS, {})
         thermostats = self.get_nowait(ATTR_THERMOSTATS, {})
-        for subdevice in (mixers | thermostats).values():
-            await subdevice.shutdown()
-
-        with suppress(AttributeError):
-            await self.regdata.shutdown()
-
+        devices: Iterable[SubDevice] = (mixers | thermostats).values()
+        await asyncio.gather(*[device.shutdown() for device in devices])
         await super().shutdown()

pyplumio/devices/mixer.py

@@ -37,8 +37,9 @@ class Mixer(SubDevice):
         For each sensor dispatch an event with the
         sensor's name and value.
         """
-        for name, value in sensors.items():
-            await self.dispatch(name, value)
+        await asyncio.gather(
+            *[self.dispatch(name, value) for name, value in sensors.items()]
+        )
 
         return True
 

pyplumio/devices/thermostat.py

@@ -33,8 +33,9 @@ class Thermostat(SubDevice):
         For each sensor dispatch an event with the
         sensor's name and value.
         """
-        for name, value in sensors.items():
-            await self.dispatch(name, value)
+        await asyncio.gather(
+            *[self.dispatch(name, value) for name, value in sensors.items()]
+        )
 
         return True
 

pyplumio/helpers/event_manager.py

@@ -138,16 +138,16 @@ class EventManager(TaskManager):
         """Call a registered callbacks and dispatch the event without waiting."""
         self.create_task(self.dispatch(name, value))
 
-    def load(self, data: dict[str, Any]) -> None:
-        """Load an event data."""
-
-        async def _dispatch_events(data: dict[str, Any]) -> None:
-            """Dispatch events for a loaded data."""
-            for key, value in data.items():
-                await self.dispatch(key, value)
-
+    async def load(self, data: dict[str, Any]) -> None:
+        """Load event data."""
         self.data = data
-        self.create_task(_dispatch_events(data))
+        await asyncio.gather(
+            *[self.dispatch(name, value) for name, value in data.items()]
+        )
+
+    def load_nowait(self, data: dict[str, Any]) -> None:
+        """Load event data without waiting."""
+        self.create_task(self.load(data))
 
     def create_event(self, name: str) -> asyncio.Event:
         """Create an event."""
@@ -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/task_manager.py

@@ -18,15 +18,14 @@ class TaskManager:
 
     def create_task(self, coro: Coroutine[Any, Any, Any]) -> asyncio.Task:
         """Create asyncio task and store a reference for it."""
-        task: asyncio.Task = asyncio.create_task(coro)
+        task = asyncio.create_task(coro)
         self._tasks.add(task)
         task.add_done_callback(self._tasks.discard)
         return task
 
-    def cancel_tasks(self) -> None:
+    def cancel_tasks(self) -> bool:
         """Cancel all tasks."""
-        for task in self._tasks:
-            task.cancel()
+        return all(task.cancel() for task in self._tasks)
 
     async def wait_until_done(self, return_exceptions: bool = True) -> None:
         """Wait for all tasks to complete."""

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,19 @@ 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."""
+        await asyncio.gather(self.read.join(), self.write.join())
+
 
 class AsyncProtocol(Protocol, EventManager):
     """Represents an async protocol.
@@ -117,11 +119,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 +141,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 +153,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))
 
@@ -174,52 +170,43 @@ class AsyncProtocol(Protocol, EventManager):
             return
 
         self.connected.clear()
-        for device in self.data.values():
-            # Notify devices about connection loss.
-            await device.dispatch(ATTR_CONNECTED, False)
-
         await self.close_writer()
-        for callback in self.on_connection_lost:
-            await callback()
+        await asyncio.gather(
+            *[device.dispatch(ATTR_CONNECTED, False) for device in self.data.values()]
+        )
+        await asyncio.gather(*[callback() for callback in self.on_connection_lost])
 
     async def shutdown(self) -> None:
         """Shutdown protocol tasks."""
-        await asyncio.gather(*[queue.join() for queue in self._queues])
-        await super(Protocol, self).shutdown()
-        for device in self.data.values():
-            await device.shutdown()
-
+        await self._queues.join()
+        self.cancel_tasks()
+        await self.wait_until_done()
+        await asyncio.gather(*[device.shutdown() for device in self.data.values()])
         if self.connected.is_set():
             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],

pyplumio/structures/ecomax_parameters.py

@@ -116,8 +116,6 @@ class EcomaxBinaryParameterDescription(
 ):
     """Represents an ecoMAX binary parameter description."""
 
-    __slots__ = ()
-
 
 ECOMAX_PARAMETERS: dict[ProductType, tuple[EcomaxParameterDescription, ...]] = {
     ProductType.ECOMAX_P: (

pyplumio/structures/network_info.py

@@ -18,7 +18,7 @@ DEFAULT_NETMASK: Final = "255.255.255.0"
 NETWORK_INFO_SIZE: Final = 25
 
 
-@dataclass
+@dataclass(frozen=True)
 class EthernetParameters:
     """Represents an ethernet parameters."""
 
@@ -35,7 +35,7 @@ class EthernetParameters:
     status: bool = True
 
 
-@dataclass
+@dataclass(frozen=True)
 class WirelessParameters(EthernetParameters):
     """Represents a wireless network parameters."""
 
@@ -50,7 +50,7 @@ class WirelessParameters(EthernetParameters):
     signal_quality: int = 100
 
 
-@dataclass
+@dataclass(frozen=True)
 class NetworkInfo:
     """Represents a network parameters."""