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

pyplumio/protocol.py

@@ -1,14 +1,15 @@
 """Contains protocol representation."""
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
 import asyncio
 from collections.abc import Awaitable, Callable
 import logging
-from typing import cast
+from typing import NamedTuple, cast
 
 from pyplumio.const import ATTR_CONNECTED, DeviceType
-from pyplumio.devices import AddressableDevice, get_device_handler_and_name
+from pyplumio.devices import AddressableDevice
 from pyplumio.exceptions import (
     FrameDataError,
     FrameError,
@@ -18,7 +19,6 @@ from pyplumio.exceptions import (
 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,36 +101,43 @@ class DummyProtocol(Protocol):
             await self.close_writer()
 
 
+class Queues(NamedTuple):
+    """Represents asyncio queues."""
+
+    read: asyncio.Queue
+    write: asyncio.Queue
+
+
 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, creates device entry 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 and send frame to
+    their respective device class for further 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)
@@ -143,7 +150,7 @@ class AsyncProtocol(Protocol, EventManager):
                 else wireless_parameters
             ),
         )
-        self._queues = (asyncio.Queue(), asyncio.Queue())
+        self._queues = Queues(asyncio.Queue(), asyncio.Queue())
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -151,11 +158,10 @@ 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))
+        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,7 +184,7 @@ class AsyncProtocol(Protocol, EventManager):
 
     async def shutdown(self) -> None:
         """Shutdown protocol tasks."""
-        await asyncio.gather(*[queue.join() for queue in self.queues])
+        await asyncio.gather(*[queue.join() for queue in self._queues])
         await super(Protocol, self).shutdown()
         for device in self.data.values():
             await device.shutdown()
@@ -187,24 +193,19 @@ class AsyncProtocol(Protocol, EventManager):
             self.connected.clear()
             await self.close_writer()
 
-    async def frame_producer(
-        self, read_queue: asyncio.Queue, write_queue: asyncio.Queue
-    ) -> None:
+    async def frame_producer(self, queues: Queues) -> 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 queues.write.qsize() > 0:
+                    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))
+                    queues.read.put_nowait(response)
 
             except FrameDataError as e:
                 _LOGGER.warning("Incorrect payload: %s", e)
@@ -220,36 +221,25 @@ class AsyncProtocol(Protocol, EventManager):
             except Exception as e:  # pylint: disable=broad-except
                 _LOGGER.exception(e)
 
-    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,4 +1,5 @@
 """Contains a frame reader and writer classes."""
+
 from __future__ import annotations
 
 import asyncio
@@ -7,9 +8,9 @@ import logging
 from typing import Final
 
 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
@@ -83,7 +84,7 @@ class FrameReader:
                 length,
                 recipient,
                 sender,
-                sender_type,
+                econet_type,
                 econet_version,
             ] = struct_header.unpack_from(buffer)
 
@@ -92,7 +93,7 @@ class FrameReader:
                 length,
                 recipient,
                 sender,
-                sender_type,
+                econet_type,
                 econet_version,
             )
 
@@ -111,13 +112,16 @@ class FrameReader:
             length,
             recipient,
             sender,
-            sender_type,
+            econet_type,
             econet_version,
         ) = await self._read_header()
 
         if recipient not in (DeviceType.ECONET, DeviceType.ALL):
             return None
 
+        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})")
 
@@ -132,13 +136,13 @@ class FrameReader:
         if payload[-2] != bcc(header + payload[:-2]):
             raise ChecksumError(f"Incorrect frame 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

pyplumio/structures/program_version.py

@@ -1,4 +1,5 @@
 """Contains a program version decoder."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -23,9 +24,9 @@ class VersionInfo:
     """Represents a version info provided in program version response."""
 
     software: str = SOFTWARE_VERSION
-    struct_tag: bytes = b"\xFF\xFF"
+    struct_tag: bytes = b"\xff\xff"
     struct_version: int = 5
-    device_id: bytes = b"\x7A\x00"
+    device_id: bytes = b"\x7a\x00"
     processor_signature: bytes = b"\x00\x00\x00"
 
 

pyplumio/structures/regulator_data.py

@@ -1,9 +1,9 @@
 """Contains a regulator data structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final
 
-from pyplumio.devices import AddressableDevice
 from pyplumio.helpers.data_types import BitArray, DataType
 from pyplumio.structures import StructureDecoder
 from pyplumio.structures.frame_versions import FrameVersionsStructure
@@ -55,9 +55,8 @@ class RegulatorDataStructure(StructureDecoder):
             message, offset + 2, data
         )
 
-        sender = self.frame.sender
-        if isinstance(sender, AddressableDevice) and (
-            schema := sender.get_nowait(ATTR_REGDATA_SCHEMA, [])
+        if (device := self.frame.sender_device) is not None and (
+            schema := device.get_nowait(ATTR_REGDATA_SCHEMA, [])
         ):
             self._bitarray_index = 0
             data[ATTR_REGDATA] = {

pyplumio/structures/regulator_data_schema.py

@@ -1,4 +1,5 @@
 """Contains data schema structure decoder."""
+
 from __future__ import annotations
 
 from typing import Any, Final

pyplumio/structures/schedules.py

@@ -1,17 +1,23 @@
 """Contains schedule decoder."""
+
 from __future__ import annotations
 
 from collections.abc import Sequence
 from dataclasses import dataclass
 from functools import reduce
 from itertools import chain
-from typing import Any, Final, cast
-
-from pyplumio.const import ATTR_PARAMETER, ATTR_SCHEDULE, ATTR_SWITCH, ATTR_TYPE
+from typing import Any, Final
+
+from pyplumio.const import (
+    ATTR_PARAMETER,
+    ATTR_SCHEDULE,
+    ATTR_SWITCH,
+    ATTR_TYPE,
+    FrameType,
+)
 from pyplumio.devices import AddressableDevice, Device
 from pyplumio.exceptions import FrameDataError
 from pyplumio.frames import Request
-from pyplumio.helpers.factory import create_instance
 from pyplumio.helpers.parameter import (
     BinaryParameter,
     BinaryParameterDescription,
@@ -84,13 +90,10 @@ class ScheduleParameter(Parameter):
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
         schedule_name, _ = self.description.name.split("_schedule_", 1)
-        return cast(
-            Request,
-            await create_instance(
-                "frames.requests.SetScheduleRequest",
-                recipient=self.device.address,
-                data=collect_schedule_data(schedule_name, self.device),
-            ),
+        return await Request.create(
+            FrameType.REQUEST_SET_SCHEDULE,
+            recipient=self.device.address,
+            data=collect_schedule_data(schedule_name, self.device),
         )
 
 

pyplumio/structures/statuses.py

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

pyplumio/structures/temperatures.py

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