PyPlumIO 0.5.19__tar.gz → 0.5.21__tar.gz

{pyplumio-0.5.19 → pyplumio-0.5.21}/.pre-commit-config.yaml

@@ -2,13 +2,13 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.2
+    rev: v0.4.7
     hooks:
       - id: ruff
         args:
           - --fix
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.6
+    rev: v2.3.0
     hooks:
         - id: codespell
   - repo: https://github.com/pre-commit/mirrors-mypy

{pyplumio-0.5.19 → pyplumio-0.5.21}/PKG-INFO

@@ -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
@@ -27,11 +27,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"
 Provides-Extra: docs
 Requires-Dist: sphinx==7.3.7; extra == "docs"

{pyplumio-0.5.19 → pyplumio-0.5.21}/PyPlumIO.egg-info/PKG-INFO

@@ -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
@@ -27,11 +27,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"
 Provides-Extra: docs
 Requires-Dist: sphinx==7.3.7; extra == "docs"

{pyplumio-0.5.19 → pyplumio-0.5.21}/PyPlumIO.egg-info/requires.txt

@@ -14,9 +14,9 @@ readthedocs-sphinx-search==0.3.2
 codespell==2.3.0
 coverage==7.5.3
 mypy==1.10.0
-pyserial-asyncio-fast==0.11
-pytest==8.2.1
+pyserial-asyncio-fast==0.12
+pytest==8.2.2
 pytest-asyncio==0.23.7
-ruff==0.4.5
-tox==4.15.0
+ruff==0.4.9
+tox==4.15.1
 types-pyserial==3.5.0.20240527

{pyplumio-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.21/pyplumio/helpers/timeout.py

@@ -0,0 +1,33 @@
+"""Contains a timeout decorator."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Coroutine
+from functools import wraps
+import logging
+from typing import Any, TypeVar
+
+from typing_extensions import ParamSpec
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def timeout(
+    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]]:
+        @wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
+
+        return wrapper
+
+    return decorator

{pyplumio-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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-0.5.19 → pyplumio-0.5.21}/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."""