PyPlumIO 0.5.19__tar.gz → 0.5.20__tar.gz

{pyplumio-0.5.19 → pyplumio-0.5.20}/.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.20}/PKG-INFO

@@ -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
@@ -30,7 +30,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"
 Provides-Extra: docs

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

@@ -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
@@ -30,7 +30,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"
 Provides-Extra: docs

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

@@ -17,6 +17,6 @@ mypy==1.10.0
 pyserial-asyncio-fast==0.11
 pytest==8.2.1
 pytest-asyncio==0.23.7
-ruff==0.4.5
+ruff==0.4.7
 tox==4.15.0
 types-pyserial==3.5.0.20240527

{pyplumio-0.5.19 → pyplumio-0.5.20}/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-0.5.19 → pyplumio-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-0.5.19 → pyplumio-0.5.20}/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.20}/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-0.5.20/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.20}/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-0.5.19 → pyplumio-0.5.20}/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.20}/pyproject.toml

@@ -38,7 +38,7 @@ test = [
     "pyserial-asyncio-fast==0.11",
     "pytest==8.2.1",
     "pytest-asyncio==0.23.7",
-    "ruff==0.4.5",
+    "ruff==0.4.7",
     "tox==4.15.0",
     "types-pyserial==3.5.0.20240527"
 ]

{pyplumio-0.5.19 → pyplumio-0.5.20}/requirements_test.txt

@@ -5,7 +5,7 @@ pre-commit==3.7.1
 pyserial-asyncio-fast==0.11
 pytest==8.2.1
 pytest-asyncio==0.23.7
-ruff==0.4.5
+ruff==0.4.7
 tomli==2.0.1
 tox==4.15.0
 types-pyserial==3.5.0.20240527

{pyplumio-0.5.19 → pyplumio-0.5.20}/tests/helpers/test_timeout.py

@@ -1,7 +1,6 @@
 """Contains tests for the timeout decorator class."""
 
 import asyncio
-import logging
 from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
@@ -9,28 +8,27 @@ import pytest
 from pyplumio.helpers.timeout import timeout
 
 
-@patch("asyncio.wait_for", new_callable=AsyncMock, side_effect=(asyncio.TimeoutError))
-async def test_timeout(mock_wait_for, caplog) -> None:
+@patch(
+    "asyncio.wait_for",
+    new_callable=AsyncMock,
+    side_effect=("test", asyncio.TimeoutError),
+)
+async def test_timeout(mock_wait_for) -> None:
     """Test a timeout decorator."""
     # Mock function to pass to the decorator.
     mock_func = Mock()
     mock_func.return_value = "test"
-    mock_func.__name__ = "func_name"
 
     # Call the decorator.
-    decorator = timeout(10, raise_exception=False)
+    decorator = timeout(10)
     wrapper = decorator(mock_func)
-    with caplog.at_level(logging.WARNING):
-        result = await wrapper("test_arg", kwarg="test_kwarg")
-
-    assert result is None
-    assert "Function 'func_name' timed out" in caplog.text
-    assert "func_name" in caplog.text
+    result = await wrapper("test_arg", kwarg="test_kwarg")
+    assert result == "test"
     mock_wait_for.assert_awaited_once_with("test", timeout=10)
     mock_func.assert_called_once_with("test_arg", kwarg="test_kwarg")
 
     # Check with raise_exception set to true.
-    decorator = timeout(10, raise_exception=True)
+    decorator = timeout(10)
     wrapper = decorator(mock_func)
     with pytest.raises(asyncio.TimeoutError):
         await wrapper("test_arg", kwarg="test_kwarg")

{pyplumio-0.5.19 → pyplumio-0.5.20}/tests/test_protocol.py

@@ -205,8 +205,8 @@ async def test_async_protocol_shutdown(
     bypass_asyncio_events,
 ) -> None:
     """Test shutting down connection with an async protocol."""
-    mock_read_queue = Mock()
-    mock_write_queue = Mock()
+    mock_read_queue = AsyncMock()
+    mock_write_queue = AsyncMock()
 
     mock_writer = AsyncMock()
     mock_writer.close = AsyncMock()
@@ -233,12 +233,7 @@ async def test_async_protocol_shutdown(
 
     mock_shutdown.assert_awaited_once()
     mock_cancel_tasks.assert_called_once()
-    assert mock_gather.call_count == 2
-    calls = [
-        call(mock_read_queue.join(), mock_write_queue.join()),
-        call(*async_protocol.tasks, return_exceptions=True),
-    ]
-    mock_gather.assert_has_awaits(calls)
+    mock_gather.assert_awaited_once_with(*async_protocol.tasks, return_exceptions=True)
     mock_writer.close.assert_awaited_once()
     assert async_protocol.writer is None
 
@@ -251,8 +246,8 @@ async def test_async_protocol_frame_producer(
     response = Response(sender=DeviceType.ECOMAX)
 
     # Create mock frame reader and writer.
-    async_protocol.reader = AsyncMock(spec=FrameReader)
-    async_protocol.reader.read = AsyncMock(
+    mock_reader = AsyncMock(spec=FrameReader)
+    mock_reader.read = AsyncMock(
         side_effect=(
             response,
             FrameError("test frame error"),
@@ -264,12 +259,14 @@ async def test_async_protocol_frame_producer(
         )
     )
 
-    async_protocol.writer = AsyncMock(spec=FrameWriter)
+    mock_writer = AsyncMock(spec=FrameWriter)
 
     # Create mock queues.
     mock_read_queue = AsyncMock(spec=asyncio.Queue)
     mock_write_queue = AsyncMock(spec=asyncio.Queue)
-    mock_write_queue.qsize = Mock(side_effect=(1, 0, 0, 0, 0, 0, 0))
+    mock_write_queue.empty = Mock(
+        side_effect=(False, True, True, True, True, True, True)
+    )
     mock_write_queue.get = AsyncMock(return_value="test_request")
 
     with (
@@ -279,7 +276,11 @@ async def test_async_protocol_frame_producer(
         ) as mock_connection_lost,
         caplog.at_level(logging.DEBUG),
     ):
-        await async_protocol.frame_producer(Queues(mock_read_queue, mock_write_queue))
+        await async_protocol.frame_producer(
+            Queues(mock_read_queue, mock_write_queue),
+            reader=mock_reader,
+            writer=mock_writer,
+        )
 
     assert caplog.record_tuples == [
         (
@@ -290,32 +291,32 @@ async def test_async_protocol_frame_producer(
         (
             "pyplumio.protocol",
             logging.DEBUG,
-            "Unknown device: test unknown device error",
+            "Can't process received frame: test unknown device error",
         ),
         (
             "pyplumio.protocol",
             logging.DEBUG,
-            "Read error: test read error",
+            "Can't process received frame: test read error",
         ),
         (
             "pyplumio.protocol",
-            logging.WARNING,
-            "Incorrect payload: test frame data error",
+            logging.DEBUG,
+            "Can't process received frame: test frame data error",
         ),
         (
             "pyplumio.protocol",
             logging.ERROR,
-            "test generic error",
+            "Unexpected exception",
         ),
     ]
 
-    async_protocol.writer.write.assert_awaited_once_with("test_request")
+    mock_writer.write.assert_awaited_once_with("test_request")
     mock_write_queue.task_done.assert_called_once()
     mock_read_queue.put_nowait.assert_called_once_with(response)
     mock_connection_lost.assert_called_once()
     assert mock_write_queue.get.await_count == 1
-    assert mock_write_queue.qsize.call_count == 7
-    assert async_protocol.reader.read.await_count == 7
+    assert mock_write_queue.empty.call_count == 7
+    assert mock_reader.read.await_count == 7
 
 
 @patch("pyplumio.frames.requests.CheckDeviceRequest.response")

pyplumio-0.5.19/pyplumio/helpers/timeout.py

@@ -1,47 +0,0 @@
-"""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, 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.
-    """
-
-    def decorator(
-        func: Callable[P, Awaitable[T]],
-    ) -> Callable[P, Coroutine[Any, Any, T | None]]:
-        @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
-
-        return wrapper
-
-    return decorator