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

pyplumio/helpers/task_manager.py

@@ -1,4 +1,5 @@
 """Contains a task manager class."""
+
 from __future__ import annotations
 
 import asyncio

pyplumio/helpers/timeout.py

@@ -1,4 +1,5 @@
 """Contains a timeout decorator."""
+
 from __future__ import annotations
 
 import asyncio
@@ -16,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/helpers/typing.py

@@ -1,4 +1,5 @@
 """Contains type aliases."""
+
 from __future__ import annotations
 
 from typing import Literal, Protocol, Union, runtime_checkable

pyplumio/helpers/uid.py

@@ -1,4 +1,5 @@
 """Contains an UID helpers."""
+
 from __future__ import annotations
 
 from functools import reduce

pyplumio/protocol.py

@@ -1,24 +1,19 @@
 """Contains protocol representation."""
+
 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 cast
 
 from pyplumio.const import ATTR_CONNECTED, DeviceType
-from pyplumio.devices import AddressableDevice, get_device_handler_and_name
-from pyplumio.exceptions import (
-    FrameDataError,
-    FrameError,
-    ReadError,
-    UnknownDeviceError,
-)
+from pyplumio.devices import AddressableDevice
+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
-from pyplumio.helpers.factory import create_instance
 from pyplumio.stream import FrameReader, FrameWriter
 from pyplumio.structures.network_info import (
     EthernetParameters,
@@ -101,49 +96,56 @@ class DummyProtocol(Protocol):
             await self.close_writer()
 
 
+@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.
 
     This protocol implements producer-consumers pattern using
     asyncio queues.
 
-    The frame producer tries to read frames from write queue, if any
-    available, and sends them to the device via frame writer.
+    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 reads stream via frame reader, creates device handler entry
-    and puts received frame and handler into the read queue.
+    It then reads stream via frame reader and puts received frame
+    into the read queue.
 
-    Frame consumers reads handler-frame tuples from the read queue and
-    sends frame to respective handler 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
     data: dict[str, AddressableDevice]
-    consumers_number: int
     _network: NetworkInfo
-    _queues: tuple[asyncio.Queue, asyncio.Queue]
+    _queues: Queues
 
     def __init__(
         self,
         ethernet_parameters: EthernetParameters | None = None,
         wireless_parameters: WirelessParameters | None = None,
-        consumers_number: int = 3,
+        consumers_count: int = 3,
     ) -> None:
         """Initialize a new async protocol."""
         super().__init__()
-        self.consumers_number = consumers_number
+        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 = (asyncio.Queue(), asyncio.Queue())
+        self._queues = Queues(read=asyncio.Queue(), write=asyncio.Queue())
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -151,11 +153,12 @@ class AsyncProtocol(Protocol, EventManager):
         """Start frame producer and consumers."""
         self.reader = FrameReader(reader)
         self.writer = FrameWriter(writer)
-        read_queue, write_queue = self.queues
-        write_queue.put_nowait(StartMasterRequest(recipient=DeviceType.ECOMAX))
-        self.create_task(self.frame_producer(*self.queues))
-        for _ in range(self.consumers_number):
-            self.create_task(self.frame_consumer(read_queue))
+        self._queues.write.put_nowait(StartMasterRequest(recipient=DeviceType.ECOMAX))
+        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))
 
         for device in self.data.values():
             device.dispatch_nowait(ATTR_CONNECTED, True)
@@ -178,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()
 
@@ -188,68 +192,46 @@ class AsyncProtocol(Protocol, EventManager):
             await self.close_writer()
 
     async def frame_producer(
-        self, read_queue: asyncio.Queue, write_queue: asyncio.Queue
+        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 write_queue.qsize() > 0:
-                    await writer.write(await write_queue.get())
-                    write_queue.task_done()
+                if not queues.write.empty():
+                    await writer.write(await queues.write.get())
+                    queues.write.task_done()
 
                 if (response := await reader.read()) is not None:
-                    device = await self.get_device_entry(
-                        cast(DeviceType, response.sender)
-                    )
-                    read_queue.put_nowait((device, 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:
+                    queues.read.put_nowait(response)
+
+            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, read_queue: asyncio.Queue) -> None:
+    async def frame_consumer(self, queue: asyncio.Queue) -> None:
         """Handle frame processing."""
         await self.connected.wait()
         while self.connected.is_set():
-            device, frame = cast(
-                tuple[AddressableDevice, Frame], await read_queue.get()
-            )
+            frame: Frame = await queue.get()
+            device = await self.get_device_entry(frame.sender)
             device.handle_frame(frame)
-            read_queue.task_done()
+            queue.task_done()
 
     async def get_device_entry(self, device_type: DeviceType) -> AddressableDevice:
-        """Set up device entry."""
-        handler, name = get_device_handler_and_name(device_type)
+        """Set up or return a device entry."""
+        name = device_type.name.lower()
         if name not in self.data:
-            self.data[name] = await self._create_device_entry(name, handler)
+            device = await AddressableDevice.create(
+                device_type, queue=self._queues.write, network=self._network
+            )
+            device.dispatch_nowait(ATTR_CONNECTED, True)
+            self.create_task(device.async_setup())
+            self.set_event(name)
+            self.data[name] = device
 
         return self.data[name]
-
-    async def _create_device_entry(self, name: str, handler: str) -> AddressableDevice:
-        """Create device entry."""
-        write_queue = self.queues[1]
-        device: AddressableDevice = await create_instance(
-            handler, queue=write_queue, network=self._network
-        )
-        device.dispatch_nowait(ATTR_CONNECTED, True)
-        self.create_task(device.async_setup())
-        self.set_event(name)
-        return device
-
-    @property
-    def queues(self) -> tuple[asyncio.Queue, asyncio.Queue]:
-        """Return the protocol queues."""
-        return self._queues

pyplumio/stream.py

@@ -1,15 +1,16 @@
 """Contains a frame reader and writer classes."""
+
 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.exceptions import ChecksumError, ReadError
-from pyplumio.frames import FRAME_START, Frame, bcc, get_frame_handler, struct_header
-from pyplumio.helpers.factory import create_instance
+from pyplumio.devices import is_known_device_type
+from pyplumio.exceptions import ChecksumError, ReadError, UnknownDeviceError
+from pyplumio.frames import FRAME_START, Frame, bcc, struct_header
 from pyplumio.helpers.timeout import timeout
 
 READER_TIMEOUT: Final = 10
@@ -53,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."""
 
@@ -64,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:
@@ -78,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,
-                sender_type,
-                econet_version,
-            ] = struct_header.unpack_from(buffer)
-
-            return (
-                buffer,
-                length,
-                recipient,
-                sender,
-                sender_type,
-                econet_version,
-            )
+            return Header(buffer, *struct_header.unpack_from(buffer))
 
         raise OSError("Serial connection broken")
 
@@ -107,38 +104,44 @@ class FrameReader:
         checksum.
         """
         (
-            header,
-            length,
+            header_bytes,
+            _,
+            frame_length,
             recipient,
             sender,
-            sender_type,
+            econet_type,
             econet_version,
         ) = await self._read_header()
 
         if recipient not in (DeviceType.ECONET, DeviceType.ALL):
             return None
 
-        if length > MAX_FRAME_LENGTH or length < MIN_FRAME_LENGTH:
-            raise ReadError(f"Unexpected frame length ({length})")
+        if not is_known_device_type(sender):
+            raise UnknownDeviceError(f"Unknown sender type ({sender})")
+
+        if frame_length > MAX_FRAME_LENGTH or frame_length < MIN_FRAME_LENGTH:
+            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: Frame = await create_instance(
-            get_frame_handler(frame_type=payload[0]),
-            recipient=recipient,
-            message=payload[1:-2],
-            sender=sender,
-            sender_type=sender_type,
+        frame = await Frame.create(
+            frame_type=payload[0],
+            recipient=DeviceType(recipient),
+            sender=DeviceType(sender),
+            econet_type=econet_type,
             econet_version=econet_version,
+            message=payload[1:-2],
         )
         _LOGGER.debug("Received frame: %s", frame)
 

pyplumio/structures/__init__.py

@@ -1,4 +1,5 @@
 """Contains structure decoders."""
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod

pyplumio/structures/alerts.py

@@ -1,4 +1,5 @@
 """Contains an alerts structure decoder."""
+
 from __future__ import annotations
 
 from collections.abc import Generator

pyplumio/structures/boiler_load.py

@@ -1,4 +1,5 @@
 """Contains a boiler load structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final

pyplumio/structures/boiler_power.py

@@ -1,4 +1,5 @@
 """Contains a boiler power structure decoder."""
+
 from __future__ import annotations
 
 import math

pyplumio/structures/ecomax_parameters.py

@@ -1,9 +1,10 @@
 """Contains regulator parameter structure decoder."""
+
 from __future__ import annotations
 
 from collections.abc import Generator
 from dataclasses import dataclass
-from typing import Any, Final, cast
+from typing import Any, Final
 
 from pyplumio.const import (
     ATTR_INDEX,
@@ -11,12 +12,12 @@ from pyplumio.const import (
     ATTR_SIZE,
     ATTR_VALUE,
     PERCENTAGE,
+    FrameType,
     ProductType,
     UnitOfMeasurement,
 )
 from pyplumio.devices import AddressableDevice
 from pyplumio.frames import Request
-from pyplumio.helpers.factory import create_instance
 from pyplumio.helpers.parameter import (
     BinaryParameter,
     BinaryParameterDescription,
@@ -47,10 +48,10 @@ class EcomaxParameter(Parameter):
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
         if self.description.name == ATTR_ECOMAX_CONTROL:
-            cls = "frames.requests.EcomaxControlRequest"
+            frame_type = FrameType.REQUEST_ECOMAX_CONTROL
             data = {ATTR_VALUE: self.values.value}
         elif self.description.name == ATTR_THERMOSTAT_PROFILE:
-            cls = "frames.requests.SetThermostatParameterRequest"
+            frame_type = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
             data = {
                 ATTR_INDEX: self._index,
                 ATTR_VALUE: self.values.value,
@@ -58,15 +59,14 @@ class EcomaxParameter(Parameter):
                 ATTR_SIZE: 1,
             }
         else:
-            cls = "frames.requests.SetEcomaxParameterRequest"
+            frame_type = FrameType.REQUEST_SET_ECOMAX_PARAMETER
             data = {
                 ATTR_INDEX: self._index,
                 ATTR_VALUE: self.values.value,
             }
 
-        return cast(
-            Request,
-            await create_instance(cls, recipient=self.device.address, data=data),
+        return await Request.create(
+            frame_type, recipient=self.device.address, data=data
         )
 
     async def set(self, value: ParameterValueType, retries: int = 5) -> bool:

pyplumio/structures/fan_power.py

@@ -1,4 +1,5 @@
 """Contains a fan power structure decoder."""
+
 from __future__ import annotations
 
 import math

pyplumio/structures/frame_versions.py

@@ -1,4 +1,5 @@
 """Contains a frame versions structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final

pyplumio/structures/fuel_consumption.py

@@ -1,4 +1,5 @@
 """Contains fuel consumption structure decoder."""
+
 from __future__ import annotations
 
 import math

pyplumio/structures/fuel_level.py

@@ -1,4 +1,5 @@
 """Contains a fuel level structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final

pyplumio/structures/lambda_sensor.py

@@ -1,4 +1,5 @@
 """Contains a lambda sensor structure decoder."""
+
 from __future__ import annotations
 
 from contextlib import suppress

pyplumio/structures/mixer_parameters.py

@@ -1,19 +1,20 @@
 """Contains a mixer parameter structure decoder."""
+
 from __future__ import annotations
 
 from collections.abc import Generator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Final, cast
+from typing import TYPE_CHECKING, Any, Final
 
 from pyplumio.const import (
     ATTR_DEVICE_INDEX,
     ATTR_INDEX,
     ATTR_VALUE,
+    FrameType,
     ProductType,
     UnitOfMeasurement,
 )
 from pyplumio.frames import Request
-from pyplumio.helpers.factory import create_instance
 from pyplumio.helpers.parameter import (
     BinaryParameter,
     BinaryParameterDescription,
@@ -44,17 +45,14 @@ class MixerParameter(Parameter):
 
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
-        return cast(
-            Request,
-            await create_instance(
-                "frames.requests.SetMixerParameterRequest",
-                recipient=self.device.parent.address,
-                data={
-                    ATTR_INDEX: self._index,
-                    ATTR_VALUE: self.values.value,
-                    ATTR_DEVICE_INDEX: self.device.index,
-                },
-            ),
+        return await Request.create(
+            FrameType.REQUEST_SET_MIXER_PARAMETER,
+            recipient=self.device.parent.address,
+            data={
+                ATTR_INDEX: self._index,
+                ATTR_VALUE: self.values.value,
+                ATTR_DEVICE_INDEX: self.device.index,
+            },
         )
 
     async def set(self, value: ParameterValueType, retries: int = 5) -> bool:

pyplumio/structures/mixer_sensors.py

@@ -1,4 +1,5 @@
 """Contains a mixer sensors structure decoder."""
+
 from __future__ import annotations
 
 from collections.abc import Generator

pyplumio/structures/modules.py

@@ -1,4 +1,5 @@
 """Contains a modules structure decoder."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass

pyplumio/structures/network_info.py

@@ -1,4 +1,5 @@
 """Contains a network info structure decoder."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass, field

pyplumio/structures/output_flags.py

@@ -1,4 +1,5 @@
 """Contains an output flags structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final

pyplumio/structures/outputs.py

@@ -1,4 +1,5 @@
 """Contains an outputs structure decoder."""
+
 from __future__ import annotations
 
 import math

pyplumio/structures/pending_alerts.py

@@ -1,4 +1,5 @@
 """Contains a pending alerts structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final

pyplumio/structures/product_info.py

@@ -1,4 +1,5 @@
 """Contains a product info structure decoder."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass