PyPlumIO 0.6.1__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."""
@@ -185,7 +185,7 @@ class DeviceStatistics:
     address: int
 
     #: Datetime object representing connection time
-    connected_since: datetime = field(default_factory=datetime.now)
+    first_seen: datetime = field(default_factory=datetime.now)
 
     #: Datetime object representing time when device was last seen
     last_seen: datetime = field(default_factory=datetime.now)
@@ -234,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
@@ -354,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.