PyPlumIO 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

pyplumio/protocol.py

@@ -27,7 +27,7 @@ from pyplumio.structures.regulator_data import ATTR_REGDATA
 
 _LOGGER = logging.getLogger(__name__)
 
-Callback: TypeAlias = Callable[[], Awaitable[None]]
+ConnectionLostCallback: TypeAlias = Callable[[], Awaitable[None]]
 
 
 class Protocol(ABC):
@@ -36,7 +36,7 @@ class Protocol(ABC):
     connected: asyncio.Event
     reader: FrameReader | None
     writer: FrameWriter | None
-    _on_connection_lost: set[Callback]
+    _on_connection_lost: set[ConnectionLostCallback]
 
     def __init__(self) -> None:
         """Initialize a new protocol."""
@@ -53,7 +53,7 @@ class Protocol(ABC):
             self.writer = None
 
     @property
-    def on_connection_lost(self) -> set[Callback]:
+    def on_connection_lost(self) -> set[ConnectionLostCallback]:
         """Return the callbacks that'll be called on connection lost."""
         return self._on_connection_lost
 
@@ -105,8 +105,8 @@ class DummyProtocol(Protocol):
 class Queues:
     """Represents asyncio queues."""
 
-    read: asyncio.Queue[Frame]
-    write: asyncio.Queue[Frame]
+    read: asyncio.Queue[Frame] = field(default_factory=asyncio.Queue)
+    write: asyncio.Queue[Frame] = field(default_factory=asyncio.Queue)
 
     async def join(self) -> None:
         """Wait for queues to finish."""
@@ -145,25 +145,29 @@ class Statistics:
     connection_losses: int = 0
 
     #: List of statistics for connected devices
-    devices: list[DeviceStatistics] = field(default_factory=list)
+    devices: set[DeviceStatistics] = field(default_factory=set)
 
-    def update_transfer_statistics(
-        self, sent: Frame | None = None, received: Frame | None = None
-    ) -> None:
-        """Update transfer statistics."""
-        if sent:
-            self.sent_bytes += sent.length
-            self.sent_frames += 1
+    def update_sent(self, frame: Frame) -> None:
+        """Update sent frames statistics."""
+        self.sent_bytes += frame.length
+        self.sent_frames += 1
 
-        if received:
-            self.received_bytes += received.length
-            self.received_frames += 1
+    def update_received(self, frame: Frame) -> None:
+        """Update received frames statistics."""
+        self.received_bytes += frame.length
+        self.received_frames += 1
 
-    def track_connection_loss(self) -> None:
-        """Increase connection loss counter and store the datetime."""
+    def update_connection_lost(self) -> None:
+        """Update connection lost counter."""
         self.connection_losses += 1
         self.connection_loss_at = datetime.now()
 
+    def update_devices(self, device: PhysicalDevice) -> None:
+        """Update connected devices."""
+        device_statistics = DeviceStatistics(address=device.address)
+        device.subscribe(ATTR_REGDATA, device_statistics.update_last_seen)
+        self.devices.add(device_statistics)
+
     def reset_transfer_statistics(self) -> None:
         """Reset transfer statistics."""
         self.sent_bytes = 0
@@ -173,18 +177,22 @@ class Statistics:
         self.failed_frames = 0
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class DeviceStatistics:
     """Represents a device statistics."""
 
-    #: Device name
-    name: str
+    #: Device address
+    address: int
 
     #: Datetime object representing connection time
-    connected_since: datetime | Literal["never"] = NEVER
+    first_seen: datetime = field(default_factory=datetime.now)
 
     #: Datetime object representing time when device was last seen
-    last_seen: datetime | Literal["never"] = NEVER
+    last_seen: datetime = field(default_factory=datetime.now)
+
+    def __hash__(self) -> int:
+        """Return a hash of the statistics based on unique address."""
+        return self.address
 
     async def update_last_seen(self, _: Any) -> None:
         """Update last seen property."""
@@ -226,9 +234,9 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             eth=ethernet_parameters or EthernetParameters(status=False),
             wlan=wireless_parameters or WirelessParameters(status=False),
         )
-        self._queues = Queues(read=asyncio.Queue(), write=asyncio.Queue())
         self._entry_lock = asyncio.Lock()
         self._statistics = Statistics()
+        self._queues = Queues()
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -241,10 +249,10 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             self.frame_producer(self._queues, reader=self.reader, writer=self.writer),
             name="frame_producer_task",
         )
-        for consumer in range(self.consumers_count):
+        for consumer_id in range(self.consumers_count):
             self.create_task(
                 self.frame_consumer(self._queues.read),
-                name=f"frame_consumer_task ({consumer})",
+                name=f"frame_consumer_task ({consumer_id})",
             )
 
         for device in self.data.values():
@@ -277,30 +285,39 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             await self._connection_close()
             await asyncio.gather(*(device.shutdown() for device in self.data.values()))
 
+    async def _write_from_queue(
+        self, writer: FrameWriter, queue: asyncio.Queue[Frame]
+    ) -> None:
+        """Send frame from the queue to the remote device."""
+        frame = await queue.get()
+        await writer.write(frame)
+        queue.task_done()
+        self.statistics.update_sent(frame)
+
+    async def _read_into_queue(
+        self, reader: FrameReader, queue: asyncio.Queue[Frame]
+    ) -> None:
+        """Read frame from the remote device into the queue."""
+        if frame := await reader.read():
+            queue.put_nowait(frame)
+            self.statistics.update_received(frame)
+
     async def frame_producer(
         self, queues: Queues, reader: FrameReader, writer: FrameWriter
     ) -> None:
         """Handle frame reads and writes."""
-        statistics = self.statistics
         await self.connected.wait()
         while self.connected.is_set():
             try:
-                request = None
                 if not queues.write.empty():
-                    request = await queues.write.get()
-                    await writer.write(request)
-                    queues.write.task_done()
-
-                if response := await reader.read():
-                    queues.read.put_nowait(response)
-
-                statistics.update_transfer_statistics(request, response)
+                    await self._write_from_queue(writer, queues.write)
 
+                await self._read_into_queue(reader, queues.read)
             except ProtocolError as e:
-                statistics.failed_frames += 1
+                self.statistics.failed_frames += 1
                 _LOGGER.debug("Can't process received frame: %s", e)
             except (OSError, asyncio.TimeoutError):
-                statistics.track_connection_loss()
+                self.statistics.update_connection_lost()
                 self.create_task(self.connection_lost())
                 break
             except Exception:
@@ -327,14 +344,7 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
                 device.dispatch_nowait(ATTR_CONNECTED, True)
                 device.dispatch_nowait(ATTR_SETUP, True)
                 await self.dispatch(name, device)
-                self.statistics.devices.append(
-                    device_statistics := DeviceStatistics(
-                        name=name,
-                        connected_since=datetime.now(),
-                        last_seen=datetime.now(),
-                    )
-                )
-                device.subscribe(ATTR_REGDATA, device_statistics.update_last_seen)
+                self.statistics.update_devices(device)
 
         return self.data[name]
 
@@ -344,4 +354,10 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
         return self._statistics
 
 
-__all__ = ["Protocol", "DummyProtocol", "AsyncProtocol", "Statistics"]
+__all__ = [
+    "Protocol",
+    "DummyProtocol",
+    "AsyncProtocol",
+    "Statistics",
+    "ConnectionLostCallback",
+]

pyplumio/structures/alerts.py

@@ -46,12 +46,12 @@ def seconds_to_datetime(timestamp: int) -> datetime:
     in seconds counted from Jan 1st, 2000.
     """
 
-    def datetime_kwargs(timestamp: int) -> Generator[Any, None, None]:
+    def datetime_kwargs(timestamp: int) -> Generator[tuple[Any, int]]:
         """Yield a tuple, that represents a single datetime kwarg."""
         for name, seconds, offset in DATETIME_INTERVALS:
             value = timestamp // seconds
             timestamp -= value * seconds
-            yield name, (value + offset)
+            yield name, value + offset
 
     return datetime(**dict(datetime_kwargs(timestamp)))
 

pyplumio/structures/ecomax_parameters.py

@@ -24,7 +24,7 @@ class EcomaxParametersStructure(StructureDecoder):
 
     def _ecomax_parameter(
         self, message: bytearray, start: int, end: int
-    ) -> Generator[tuple[int, ParameterValues], None, None]:
+    ) -> Generator[tuple[int, ParameterValues]]:
         """Unpack an ecoMAX parameter."""
         for index in range(start, start + end):
             if parameter := unpack_parameter(message, self._offset):

pyplumio/structures/frame_versions.py

@@ -23,8 +23,9 @@ class FrameVersionsStructure(StructureDecoder):
     def _unpack_frame_versions(self, message: bytearray) -> tuple[FrameType | int, int]:
         """Unpack frame versions."""
         frame_type = message[self._offset]
-        version = UnsignedShort.from_bytes(message, self._offset + 1)
-        self._offset += version.size + 1
+        self._offset += 1
+        version = UnsignedShort.from_bytes(message, self._offset)
+        self._offset += version.size
         with suppress(ValueError):
             frame_type = FrameType(frame_type)
 

pyplumio/structures/mixer_parameters.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Generator
-from typing import Any, Final
+from typing import Any, Final, TypeAlias
 
 from pyplumio.parameters import ParameterValues, unpack_parameter
 from pyplumio.structures import StructureDecoder
@@ -13,6 +13,8 @@ ATTR_MIXER_PARAMETERS: Final = "mixer_parameters"
 
 MIXER_PARAMETER_SIZE: Final = 3
 
+_ParameterValues: TypeAlias = tuple[int, ParameterValues]
+
 
 class MixerParametersStructure(StructureDecoder):
     """Represents a mixer parameters data structure."""
@@ -23,7 +25,7 @@ class MixerParametersStructure(StructureDecoder):
 
     def _mixer_parameter(
         self, message: bytearray, start: int, end: int
-    ) -> Generator[tuple[int, ParameterValues], None, None]:
+    ) -> Generator[_ParameterValues]:
         """Get a single mixer parameter."""
         for index in range(start, start + end):
             if parameter := unpack_parameter(message, self._offset):
@@ -33,7 +35,7 @@ class MixerParametersStructure(StructureDecoder):
 
     def _mixer_parameters(
         self, message: bytearray, mixers: int, start: int, end: int
-    ) -> Generator[tuple[int, list[tuple[int, ParameterValues]]], None, None]:
+    ) -> Generator[tuple[int, list[_ParameterValues]]]:
         """Get parameters for a mixer."""
         for index in range(mixers):
             if parameters := list(self._mixer_parameter(message, start, end)):

pyplumio/structures/network_info.py

@@ -88,6 +88,7 @@ class NetworkInfoStructure(Structure):
         self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
     ) -> tuple[dict[str, Any], int]:
         """Decode bytes and return message data and offset."""
+        offset += 1
         return (
             ensure_dict(
                 data,

pyplumio/structures/product_info.py

@@ -63,7 +63,7 @@ def format_model_name(model_name: str) -> str:
     return model_name
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, slots=True, kw_only=True)
 class ProductInfo:
     """Represents a product info provided by an UID response."""
 

pyplumio/structures/program_version.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 import struct
 from typing import Any, Final
 
-from pyplumio._version import __version_tuple__
+from pyplumio import version_tuple
 from pyplumio.structures import Structure
 from pyplumio.utils import ensure_dict
 
@@ -14,7 +14,7 @@ ATTR_VERSION: Final = "version"
 
 VERSION_INFO_SIZE: Final = 15
 
-SOFTWARE_VERSION: Final = ".".join(str(x) for x in __version_tuple__[0:3])
+SOFTWARE_VERSION: Final = ".".join(str(x) for x in version_tuple[0:3])
 
 struct_program_version = struct.Struct("<2sB2s3s3HB")
 

pyplumio/structures/schedules.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable, Iterator, MutableMapping, Sequence
+from collections.abc import Iterable, Iterator, MutableMapping
 from dataclasses import dataclass
 import datetime as dt
-from functools import lru_cache, reduce
-from typing import Annotated, Any, Final, get_args
+from functools import lru_cache
+from typing import Annotated, Any, Final, TypeAlias, get_args
 
 from pyplumio.const import (
     ATTR_PARAMETER,
@@ -19,7 +19,6 @@ from pyplumio.const import (
     State,
 )
 from pyplumio.devices import Device, PhysicalDevice
-from pyplumio.exceptions import FrameDataError
 from pyplumio.frames import Request
 from pyplumio.parameters import (
     Number,
@@ -31,8 +30,8 @@ from pyplumio.parameters import (
     SwitchDescription,
     unpack_parameter,
 )
-from pyplumio.structures import Structure
-from pyplumio.utils import ensure_dict
+from pyplumio.structures import StructureDecoder
+from pyplumio.utils import ensure_dict, split_byte
 
 ATTR_SCHEDULES: Final = "schedules"
 ATTR_SCHEDULE_PARAMETERS: Final = "schedule_parameters"
@@ -156,7 +155,7 @@ def collect_schedule_data(name: str, device: Device) -> dict[str, Any]:
 
 TIME_FORMAT: Final = "%H:%M"
 
-Time = Annotated[str, "Time string in %H:%M format"]
+Time: TypeAlias = Annotated[str, "Time string in %H:%M format"]
 
 MIDNIGHT: Final = Time("00:00")
 MIDNIGHT_DT = dt.datetime.strptime(MIDNIGHT, TIME_FORMAT)
@@ -305,51 +304,20 @@ class Schedule(Iterable):
         )
 
 
-def _split_byte(byte: int) -> list[bool]:
-    """Split single byte into an eight bits."""
-    return [bool(byte & (1 << bit)) for bit in reversed(range(8))]
-
-
-def _join_bits(bits: Sequence[int | bool]) -> int:
-    """Join eight bits into a single byte."""
-    return reduce(lambda bit, byte: (bit << 1) | byte, bits)
-
-
-class SchedulesStructure(Structure):
+class SchedulesStructure(StructureDecoder):
     """Represents a schedule data structure."""
 
     __slots__ = ("_offset",)
 
     _offset: int
 
-    def encode(self, data: dict[str, Any]) -> bytearray:
-        """Encode data to the bytearray message."""
-        try:
-            header = bytearray(
-                b"\1"
-                + SCHEDULES.index(data[ATTR_TYPE]).to_bytes(
-                    length=1, byteorder="little"
-                )
-                + int(data[ATTR_SWITCH]).to_bytes(length=1, byteorder="little")
-                + int(data[ATTR_PARAMETER]).to_bytes(length=1, byteorder="little")
-            )
-            schedule = data[ATTR_SCHEDULE]
-        except (KeyError, ValueError) as e:
-            raise FrameDataError from e
-
-        return header + bytearray(
-            _join_bits(day[i : i + 8])
-            for day in schedule
-            for i in range(0, len(day), 8)
-        )
-
     def _unpack_schedule(self, message: bytearray) -> list[list[bool]]:
         """Unpack a schedule."""
         offset = self._offset
         schedule = [
             bit
             for i in range(offset, offset + SCHEDULE_SIZE)
-            for bit in _split_byte(message[i])
+            for bit in split_byte(message[i])
         ]
         self._offset = offset + SCHEDULE_SIZE
         # Split the schedule. Each day consists of 48 half-hour intervals.