PyPlumIO 0.5.50__py3-none-any.whl → 0.5.52__py3-none-any.whl

pyplumio/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.50'
-__version_tuple__ = version_tuple = (0, 5, 50)
+__version__ = version = '0.5.52'
+__version_tuple__ = version_tuple = (0, 5, 52)

pyplumio/const.py

@@ -91,13 +91,6 @@ class ProductType(IntEnum):
     ECOMAX_I = 1
 
 
-@unique
-class ProductModel(Enum):
-    """Contains device models."""
-
-    ECOMAX_860D3_HB = "ecoMAX 860D3-HB"
-
-
 @unique
 class AlertType(IntEnum):
     """Contains alert types."""

pyplumio/devices/__init__.py

@@ -64,7 +64,7 @@ class Device(ABC, EventManager):
         self,
         name: str,
         value: NumericType | State | bool,
-        retries: int = 5,
+        retries: int = 0,
         timeout: float | None = None,
     ) -> bool:
         """Set a parameter value.
@@ -74,7 +74,7 @@ class Device(ABC, EventManager):
         :param value: New value for the parameter
         :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
-            times, defaults to 5
+            times, defaults to 0 (disabled)
         :type retries: int, optional
         :param timeout: Wait this amount of seconds for confirmation,
             defaults to `None`
@@ -96,7 +96,7 @@ class Device(ABC, EventManager):
         self,
         name: str,
         value: NumericType | State | bool,
-        retries: int = 5,
+        retries: int = 0,
         timeout: float | None = None,
     ) -> None:
         """Set a parameter value without waiting for the result.
@@ -106,7 +106,7 @@ class Device(ABC, EventManager):
         :param value: New value for the parameter
         :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
-            times, defaults to 5
+            times, defaults to 0 (disabled)
         :type retries: int, optional
         :param timeout: Wait this amount of seconds for confirmation.
             As this method operates in the background without waiting,

pyplumio/devices/ecomax.py

@@ -27,7 +27,6 @@ from pyplumio.exceptions import RequestError
 from pyplumio.filters import on_change
 from pyplumio.frames import DataFrameDescription, Frame, Request
 from pyplumio.helpers.event_manager import event_listener
-from pyplumio.helpers.schedule import Schedule, ScheduleDay
 from pyplumio.parameters import ParameterValues
 from pyplumio.parameters.ecomax import (
     ECOMAX_CONTROL_PARAMETER,
@@ -51,6 +50,8 @@ from pyplumio.structures.schedules import (
     ATTR_SCHEDULES,
     SCHEDULE_PARAMETERS,
     SCHEDULES,
+    Schedule,
+    ScheduleDay,
     ScheduleNumber,
     ScheduleSwitch,
     ScheduleSwitchDescription,
@@ -303,8 +304,7 @@ class EcoMAX(PhysicalDevice):
 
     @event_listener
     async def on_event_mixer_parameters(
-        self,
-        parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
+        self, parameters: dict[int, Any] | None
     ) -> bool:
         """Handle mixer parameters and dispatch the events."""
         _LOGGER.debug("Received mixer parameters")
@@ -320,9 +320,7 @@ class EcoMAX(PhysicalDevice):
         return False
 
     @event_listener
-    async def on_event_mixer_sensors(
-        self, sensors: dict[int, dict[str, Any]] | None
-    ) -> bool:
+    async def on_event_mixer_sensors(self, sensors: dict[int, Any] | None) -> bool:
         """Update mixer sensors and dispatch the events."""
         _LOGGER.debug("Received mixer sensors")
         if sensors:
@@ -372,8 +370,7 @@ class EcoMAX(PhysicalDevice):
 
     @event_listener
     async def on_event_thermostat_parameters(
-        self,
-        parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
+        self, parameters: dict[int, Any] | None
     ) -> bool:
         """Handle thermostat parameters and dispatch the events."""
         _LOGGER.debug("Received thermostat parameters")
@@ -403,9 +400,7 @@ class EcoMAX(PhysicalDevice):
         return None
 
     @event_listener
-    async def on_event_thermostat_sensors(
-        self, sensors: dict[int, dict[str, Any]] | None
-    ) -> bool:
+    async def on_event_thermostat_sensors(self, sensors: dict[int, Any] | None) -> bool:
         """Update thermostat sensors and dispatch the events."""
         _LOGGER.debug("Received thermostat sensors")
         if sensors:

pyplumio/filters.py

@@ -86,7 +86,7 @@ def is_close(
 ) -> bool:
     """Check if value is significantly changed."""
     if isinstance(old, Parameter) and isinstance(new, Parameter):
-        return new.pending_update or old.values.__ne__(new.values)
+        return new.update_pending.is_set() or old.values.__ne__(new.values)
 
     if tolerance and isinstance(old, SupportsFloat) and isinstance(new, SupportsFloat):
         return not math.isclose(old, new, abs_tol=tolerance)

pyplumio/frames/__init__.py

@@ -15,10 +15,14 @@ from pyplumio.utils import ensure_dict, to_camelcase
 
 FRAME_START: Final = 0x68
 FRAME_END: Final = 0x16
-HEADER_OFFSET: Final = 0
+
+
+HEADER_INDEX: Final = 0
 FRAME_TYPE_SIZE: Final = 1
-CRC_SIZE: Final = 1
+BCC_SIZE: Final = 1
+BCC_INDEX: Final = -2
 DELIMITER_SIZE: Final = 1
+
 ECONET_TYPE: Final = 48
 ECONET_VERSION: Final = 5
 
@@ -199,7 +203,7 @@ class Frame(ABC):
             struct_header.size
             + FRAME_TYPE_SIZE
             + len(self.message)
-            + CRC_SIZE
+            + BCC_SIZE
             + DELIMITER_SIZE
         )
 
@@ -209,7 +213,7 @@ class Frame(ABC):
         buffer = bytearray(struct_header.size)
         struct_header.pack_into(
             buffer,
-            HEADER_OFFSET,
+            HEADER_INDEX,
             FRAME_START,
             self.length,
             int(self.recipient),

pyplumio/parameters/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 import asyncio
+from contextlib import suppress
 from dataclasses import dataclass
 import logging
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, get_args
@@ -72,11 +73,19 @@ NumericType: TypeAlias = Union[int, float]
 class Parameter(ABC):
     """Represents a base parameter."""
 
-    __slots__ = ("device", "description", "_pending_update", "_index", "_values")
+    __slots__ = (
+        "device",
+        "description",
+        "_update_done",
+        "_update_pending",
+        "_index",
+        "_values",
+    )
 
     device: Device
     description: ParameterDescription
-    _pending_update: bool
+    _update_done: asyncio.Event
+    _update_pending: asyncio.Event
     _index: int
     _values: ParameterValues
 
@@ -91,8 +100,9 @@ class Parameter(ABC):
         self.device = device
         self.description = description
         self._index = index
-        self._pending_update = False
         self._index = index
+        self._update_done = asyncio.Event()
+        self._update_pending = asyncio.Event()
         self._values = values if values else ParameterValues(0, 0, 0)
 
     def __repr__(self) -> str:
@@ -171,21 +181,19 @@ class Parameter(ABC):
         )
         return type(self)(self.device, self.description, values)
 
-    async def set(self, value: Any, retries: int = 5, timeout: float = 5.0) -> bool:
+    async def set(self, value: Any, retries: int = 0, timeout: float = 5.0) -> bool:
         """Set a parameter value."""
         self.validate(value)
         return await self._attempt_update(self._pack_value(value), retries, timeout)
 
-    def set_nowait(self, value: Any, retries: int = 5, timeout: float = 5.0) -> None:
+    def set_nowait(self, value: Any, retries: int = 0, timeout: float = 5.0) -> None:
         """Set a parameter value without waiting."""
         self.validate(value)
         self.device.create_task(
             self._attempt_update(self._pack_value(value), retries, timeout)
         )
 
-    async def _attempt_update(
-        self, value: int, retries: int = 5, timeout: float = 5.0
-    ) -> bool:
+    async def _attempt_update(self, value: int, retries: int, timeout: float) -> bool:
         """Attempt to update a parameter value on the remote device."""
         _LOGGER.info(
             "Attempting to update '%s' parameter to %d", self.description.name, value
@@ -196,36 +204,58 @@ class Parameter(ABC):
 
         self._values.value = value
         request = await self.create_request()
-        if self.description.optimistic or not (initial_retries := retries):
-            # No retries
+        if self.description.optimistic:
             await self.device.queue.put(request)
             return True
 
-        self._pending_update = True
-        while self.pending_update:
-            if retries <= 0:
-                _LOGGER.warning(
-                    "Unable to confirm update of '%s' parameter after %d retries",
-                    self.description.name,
-                    initial_retries,
-                )
-                return False
+        self.update_done.clear()
+        self.update_pending.set()
+        if retries > 0:
+            return await self._attempt_update_with_retries(
+                request, retries=retries, timeout=timeout
+            )
 
-            await self.device.queue.put(request)
-            await asyncio.sleep(timeout)
-            retries -= 1
+        return await self._send_update_request(request, timeout=timeout)
 
-        return True
+    async def _attempt_update_with_retries(
+        self, request: Request, retries: int, timeout: float
+    ) -> bool:
+        """Send update request and retry until success."""
+        for _ in range(retries):
+            if await self._send_update_request(request, timeout=timeout):
+                return True
+
+        _LOGGER.warning(
+            "Unable to confirm update of '%s' parameter after %d retries",
+            self.description.name,
+            retries,
+        )
+        return False
+
+    async def _send_update_request(self, request: Request, timeout: float) -> bool:
+        """Send update request to the remote and confirm the result."""
+        await self.device.queue.put(request)
+        with suppress(asyncio.TimeoutError):
+            # Wait for the update to be done
+            await asyncio.wait_for(self.update_done.wait(), timeout=timeout)
+
+        return self.update_done.is_set()
 
     def update(self, values: ParameterValues) -> None:
         """Update the parameter values."""
-        self._pending_update = False
+        self.update_done.set()
+        self.update_pending.clear()
         self._values = values
 
     @property
-    def pending_update(self) -> bool:
-        """Check if parameter is pending update on the device."""
-        return self._pending_update
+    def update_done(self) -> asyncio.Event:
+        """Check if parameter is updated on the device."""
+        return self._update_done
+
+    @property
+    def update_pending(self) -> asyncio.Event:
+        """Check if parameter is updated on the device."""
+        return self._update_pending
 
     @property
     def values(self) -> ParameterValues:
@@ -325,16 +355,16 @@ class Number(Parameter):
         return True
 
     async def set(
-        self, value: NumericType, retries: int = 5, timeout: float = 5.0
+        self, value: NumericType, retries: int = 0, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
-        return await super().set(value, retries, timeout)
+        return await super().set(value, retries=retries, timeout=timeout)
 
     def set_nowait(
-        self, value: NumericType, retries: int = 5, timeout: float = 5.0
+        self, value: NumericType, retries: int = 0, timeout: float = 5.0
     ) -> None:
         """Set a parameter value without waiting."""
-        super().set_nowait(value, retries, timeout)
+        super().set_nowait(value, retries=retries, timeout=timeout)
 
     async def create_request(self) -> Request:
         """Create a request to change the number."""
@@ -420,16 +450,16 @@ class Switch(Parameter):
         return True
 
     async def set(
-        self, value: State | bool, retries: int = 5, timeout: float = 5.0
+        self, value: State | bool, retries: int = 0, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
-        return await super().set(value, retries, timeout)
+        return await super().set(value, retries=retries, timeout=timeout)
 
     def set_nowait(
-        self, value: State | bool, retries: int = 5, timeout: float = 5.0
+        self, value: State | bool, retries: int = 0, timeout: float = 5.0
     ) -> None:
         """Set a switch value without waiting."""
-        super().set_nowait(value, retries, timeout)
+        super().set_nowait(value, retries=retries, timeout=timeout)
 
     async def turn_on(self) -> bool:
         """Set a switch value to 'on'.

pyplumio/parameters/custom/__init__.py

@@ -29,7 +29,7 @@ class Signature:
 class CustomParameter:
     """Represents a custom parameter."""
 
-    __slot__ = ("original", "replacement")
+    __slots__ = ("original", "replacement")
 
     original: str
     replacement: ParameterDescription
@@ -38,8 +38,6 @@ class CustomParameter:
 class CustomParameters:
     """Represents a custom parameters."""
 
-    __slots__ = ("signature", "replacements")
-
     signature: ClassVar[Signature]
     replacements: ClassVar[Sequence[CustomParameter]]
 

pyplumio/parameters/custom/ecomax_860d3_hb.py

@@ -8,8 +8,6 @@ from pyplumio.parameters.ecomax import EcomaxNumberDescription, EcomaxSwitchDesc
 class EcoMAX860D3HB(CustomParameters):
     """Replacements for ecoMAX 860D3-HB."""
 
-    __slots__ = ()
-
     signature = Signature(model="ecoMAX 860D3-HB", id=48)
 
     replacements = (

pyplumio/protocol.py

@@ -230,15 +230,15 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     @acache
     async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
         """Return the device entry."""
+        name = device_type.name.lower()
         async with self._entry_lock:
-            name = device_type.name.lower()
             if name not in self.data:
                 device = await PhysicalDevice.create(
                     device_type, queue=self._queues.write, network=self._network
                 )
                 device.dispatch_nowait(ATTR_CONNECTED, True)
                 device.dispatch_nowait(ATTR_SETUP, True)
-                await self.dispatch(device_type.name.lower(), device)
+                await self.dispatch(name, device)
 
         return self.data[name]
 

pyplumio/stream.py

@@ -5,14 +5,16 @@ from __future__ import annotations
 import asyncio
 from asyncio import IncompleteReadError, StreamReader, StreamWriter
 import logging
-from typing import Final, NamedTuple
+from typing import Final, NamedTuple, SupportsIndex
 
 from pyplumio.const import DeviceType
 from pyplumio.devices import is_known_device_type
 from pyplumio.exceptions import ChecksumError, ReadError, UnknownDeviceError
 from pyplumio.frames import (
+    BCC_INDEX,
     DELIMITER_SIZE,
     FRAME_START,
+    FRAME_TYPE_SIZE,
     HEADER_SIZE,
     Frame,
     bcc,
@@ -26,6 +28,8 @@ WRITER_TIMEOUT: Final = 10
 MIN_FRAME_LENGTH: Final = 10
 MAX_FRAME_LENGTH: Final = 1000
 
+DEFAULT_BUFFER_SIZE: Final = 5000
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -63,6 +67,103 @@ class FrameWriter:
         await self._writer.wait_closed()
 
 
+class BufferManager:
+    """Represents a buffered reader for reading frames."""
+
+    __slots__ = ("_buffer", "_reader")
+
+    _buffer: bytearray
+    _reader: StreamReader
+
+    def __init__(self, reader: StreamReader) -> None:
+        """Initialize a new buffered reader."""
+        self._buffer = bytearray()
+        self._reader = reader
+
+    async def ensure_buffer(self, size: int) -> None:
+        """Ensure the internal buffer size."""
+        bytes_to_read = size - len(self._buffer)
+        if bytes_to_read <= 0:
+            return None
+
+        try:
+            data = await self._reader.readexactly(bytes_to_read)
+            self._buffer.extend(data)
+            self.trim_to(size)
+        except IncompleteReadError as e:
+            raise ReadError(
+                f"Incomplete read. Tried to read {bytes_to_read} additional bytes "
+                f"to reach a total of {size}, but only {len(e.partial)} bytes were "
+                "available from stream."
+            ) from e
+        except asyncio.CancelledError:
+            _LOGGER.debug("Read operation cancelled while ensuring buffer")
+            raise
+        except Exception as e:
+            raise OSError(
+                f"Serial connection broken while trying to ensure {size} bytes: {e}"
+            ) from e
+
+    async def consume(self, size: int) -> None:
+        """Consume the specified number of bytes from the buffer."""
+        await self.ensure_buffer(size)
+        self._buffer = self._buffer[size:]
+
+    async def peek(self, size: int) -> bytearray:
+        """Read the specified number of bytes without consuming them."""
+        await self.ensure_buffer(size)
+        return self._buffer[:size]
+
+    async def read(self, size: int) -> bytearray:
+        """Read the bytes from buffer or stream and consume them."""
+        try:
+            return await self.peek(size)
+        finally:
+            await self.consume(size)
+
+    def seek_to(self, delimiter: SupportsIndex) -> bool:
+        """Trim the buffer to the first occurrence of the delimiter.
+
+        Returns True if the delimiter was found and trimmed, False otherwise.
+        """
+        if not self._buffer or (index := self._buffer.find(delimiter)) == -1:
+            return False
+
+        self._buffer = self._buffer[index:]
+        return True
+
+    def trim_to(self, size: int) -> None:
+        """Trim buffer to size."""
+        if len(self._buffer) > size:
+            self._buffer = self._buffer[-size:]
+
+    async def fill(self) -> None:
+        """Fill the buffer with data from the stream."""
+        try:
+            chunk = await self._reader.read(MAX_FRAME_LENGTH)
+        except asyncio.CancelledError:
+            _LOGGER.debug("Read operation cancelled while filling read buffer.")
+            raise
+        except Exception as e:
+            raise OSError(
+                f"Serial connection broken while filling read buffer: {e}"
+            ) from e
+
+        if not chunk:
+            _LOGGER.debug("Stream ended while filling read buffer.")
+            raise OSError(
+                "Serial connection broken: stream ended while filling read buffer"
+            )
+
+        self._buffer.extend(chunk)
+        self.trim_to(DEFAULT_BUFFER_SIZE)
+
+    @property
+    def buffer(self) -> bytearray:
+        """Return the internal buffer."""
+        return self._buffer
+
+
 class Header(NamedTuple):
     """Represents a frame header."""
 
@@ -76,81 +177,65 @@ class Header(NamedTuple):
 class FrameReader:
     """Represents a frame reader."""
 
-    __slots__ = ("_reader",)
+    __slots__ = ("_buffer",)
 
-    _reader: StreamReader
+    _buffer: BufferManager
 
     def __init__(self, reader: StreamReader) -> None:
         """Initialize a new frame reader."""
-        self._reader = reader
-
-    async def _read_header(self) -> tuple[Header, bytes]:
-        """Locate and read a frame header.
-
-        Raise pyplumio.ReadError if header size is too small and
-        OSError if serial connection is broken.
-        """
-        while buffer := await self._reader.read(DELIMITER_SIZE):
-            if FRAME_START not in buffer:
-                continue
-
-            try:
-                buffer += await self._reader.readexactly(HEADER_SIZE - DELIMITER_SIZE)
-            except IncompleteReadError as e:
-                raise ReadError(
-                    f"Incomplete header, expected {e.expected} bytes"
-                ) from e
+        self._buffer = BufferManager(reader)
 
-            return Header(*struct_header.unpack_from(buffer)[DELIMITER_SIZE:]), buffer
+    async def _read_header(self) -> Header:
+        """Locate and read a frame header."""
+        while True:
+            if self._buffer.seek_to(FRAME_START):
+                header_bytes = await self._buffer.peek(HEADER_SIZE)
+                return Header(*struct_header.unpack_from(header_bytes)[DELIMITER_SIZE:])
 
-        raise OSError("Serial connection broken")
+            await self._buffer.fill()
 
     @timeout(READER_TIMEOUT)
     async def read(self) -> Frame | None:
-        """Read the frame and return corresponding handler object.
-
-        Raise pyplumio.UnknownDeviceError when sender device has an
-        unknown address, raise pyplumio.ReadError on unexpected frame
-        length or incomplete frame, raise pyplumio.ChecksumError on
-        incorrect frame checksum.
-        """
-        header, buffer = await self._read_header()
+        """Read the frame and return corresponding handler object."""
+        header = await self._read_header()
         frame_length, recipient, sender, econet_type, econet_version = header
 
-        if recipient not in (DeviceType.ECONET, DeviceType.ALL):
-            # Not an intended recipient, ignore the frame.
-            return None
-
-        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:
+            await self._buffer.consume(HEADER_SIZE)
             raise ReadError(
                 f"Unexpected frame length ({frame_length}), expected between "
                 f"{MIN_FRAME_LENGTH} and {MAX_FRAME_LENGTH}"
             )
 
-        try:
-            buffer += await self._reader.readexactly(frame_length - HEADER_SIZE)
-        except IncompleteReadError as e:
-            raise ReadError(f"Incomplete frame, expected {e.expected} bytes") from e
-
-        if (checksum := bcc(buffer[:-2])) and checksum != buffer[-2]:
+        frame_bytes = await self._buffer.peek(frame_length)
+        checksum = bcc(frame_bytes[:BCC_INDEX])
+        if checksum != frame_bytes[BCC_INDEX]:
+            await self._buffer.consume(HEADER_SIZE)
             raise ChecksumError(
                 f"Incorrect frame checksum: calculated {checksum}, "
-                f"expected {buffer[-2]}. "
-                f"Frame data: {buffer.hex()}"
+                f"expected {frame_bytes[BCC_INDEX]}. Frame data: {frame_bytes.hex()}"
+            )
+
+        await self._buffer.consume(frame_length)
+        if recipient not in (DeviceType.ECONET, DeviceType.ALL):
+            _LOGGER.debug(
+                "Skipping frame intended for different recipient (%s)", recipient
             )
+            return None
+
+        if not is_known_device_type(sender):
+            raise UnknownDeviceError(f"Unknown sender type ({sender})")
 
+        payload_bytes = frame_bytes[HEADER_SIZE:BCC_INDEX]
         frame = await Frame.create(
-            frame_type=buffer[HEADER_SIZE],
+            frame_type=payload_bytes[0],
             recipient=DeviceType(recipient),
             sender=DeviceType(sender),
             econet_type=econet_type,
             econet_version=econet_version,
-            message=buffer[HEADER_SIZE + 1 : -2],
+            message=payload_bytes[FRAME_TYPE_SIZE:],
         )
-        _LOGGER.debug("Received frame: %s, bytes: %s", frame, buffer.hex())
+        _LOGGER.debug("Received frame: %s, bytes: %s", frame, frame_bytes.hex())
 
         return frame
 

pyplumio/structures/alerts.py

@@ -99,7 +99,7 @@ class AlertsStructure(StructureDecoder):
         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."""
-        total_alerts = message[offset + 0]
+        total_alerts = message[offset]
         start = message[offset + 1]
         end = message[offset + 2]
         self._offset = offset + 3
@@ -121,4 +121,4 @@ class AlertsStructure(StructureDecoder):
         )
 
 
-__all__ = ["AlertsStructure", "Alert"]
+__all__ = ["AlertsStructure", "Alert", "ATTR_ALERTS", "ATTR_TOTAL_ALERTS"]

pyplumio/structures/lambda_sensor.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from contextlib import suppress
-import math
 from typing import Any, Final
 
 from pyplumio.const import BYTE_UNDEFINED, LambdaState
@@ -43,9 +42,7 @@ class LambdaSensorStructure(StructureDecoder):
                 {
                     ATTR_LAMBDA_STATE: lambda_state,
                     ATTR_LAMBDA_TARGET: lambda_target,
-                    ATTR_LAMBDA_LEVEL: (
-                        None if math.isnan(level.value) else (level.value / 10)
-                    ),
+                    ATTR_LAMBDA_LEVEL: level.value / 10,
                 },
             ),
             offset,

pyplumio/structures/product_info.py

@@ -3,20 +3,55 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from functools import cache
+from functools import cache, reduce
 import re
 import struct
 from typing import Any, Final
 
 from pyplumio.const import ProductType
 from pyplumio.data_types import UnsignedShort, VarBytes, VarString
-from pyplumio.helpers.uid import unpack_uid
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 
 ATTR_PRODUCT: Final = "product"
 
 
+CRC: Final = 0xA3A3
+POLYNOMIAL: Final = 0xA001
+BASE5_KEY: Final = "0123456789ABCDEFGHIJKLMNZPQRSTUV"
+
+
+def _base5(buffer: bytes) -> str:
+    """Encode bytes to a base5 encoded string."""
+    number = int.from_bytes(buffer, byteorder="little")
+    output = []
+    while number:
+        output.append(BASE5_KEY[number & 0b00011111])
+        number >>= 5
+
+    return "".join(reversed(output))
+
+
+def _crc16(buffer: bytes) -> bytes:
+    """Return a CRC 16."""
+    crc16 = reduce(_crc16_byte, buffer, CRC)
+    return crc16.to_bytes(length=2, byteorder="little")
+
+
+def _crc16_byte(crc: int, byte: int) -> int:
+    """Add a byte to the CRC."""
+    crc ^= byte
+    for _ in range(8):
+        crc = (crc >> 1) ^ POLYNOMIAL if crc & 1 else crc >> 1
+
+    return crc
+
+
+def unpack_uid(buffer: bytes) -> str:
+    """Unpack UID from bytes."""
+    return _base5(buffer + _crc16(buffer))
+
+
 @cache
 def format_model_name(model_name: str) -> str:
     """Format a device model name."""

pyplumio/structures/schedules.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Iterable, Iterator, MutableMapping, Sequence
 from dataclasses import dataclass
-from functools import reduce
-from typing import Any, Final
+import datetime as dt
+from functools import lru_cache, reduce
+from typing import Annotated, Any, Final, get_args
 
 from dataslots import dataslots
 
@@ -14,7 +15,10 @@ from pyplumio.const import (
     ATTR_SCHEDULE,
     ATTR_SWITCH,
     ATTR_TYPE,
+    STATE_OFF,
+    STATE_ON,
     FrameType,
+    State,
 )
 from pyplumio.devices import Device, PhysicalDevice
 from pyplumio.exceptions import FrameDataError
@@ -156,6 +160,169 @@ 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"]
+
+MIDNIGHT: Final = Time("00:00")
+MIDNIGHT_DT = dt.datetime.strptime(MIDNIGHT, TIME_FORMAT)
+
+STEP = dt.timedelta(minutes=30)
+
+
+def get_time(
+    index: int, start: dt.datetime = MIDNIGHT_DT, step: dt.timedelta = STEP
+) -> Time:
+    """Return time for a specific index."""
+    time_dt = start + (step * index)
+    return f"{time_dt.hour:02d}:{time_dt.minute:02d}"
+
+
+@lru_cache(maxsize=10)
+def get_time_range(start: Time, end: Time, step: dt.timedelta = STEP) -> list[Time]:
+    """Get a time range.
+
+    Start and end boundaries should be specified in %H:%M format.
+    Both are inclusive.
+    """
+    start_dt = dt.datetime.strptime(start, TIME_FORMAT)
+    end_dt = dt.datetime.strptime(end, TIME_FORMAT)
+
+    if end_dt == MIDNIGHT_DT:
+        # Upper boundary of the interval is midnight.
+        end_dt += dt.timedelta(hours=24) - step
+
+    if end_dt <= start_dt:
+        raise ValueError(
+            f"Invalid time range: start time ({start}) must be earlier "
+            f"than end time ({end})."
+        )
+
+    seconds = (end_dt - start_dt).total_seconds()
+    steps = seconds // step.total_seconds() + 1
+
+    return [get_time(index, start=start_dt, step=step) for index in range(int(steps))]
+
+
+class ScheduleDay(MutableMapping):
+    """Represents a single day of schedule."""
+
+    __slots__ = ("_schedule",)
+
+    _schedule: dict[Time, bool]
+
+    def __init__(self, schedule: dict[Time, bool]) -> None:
+        """Initialize a new schedule day."""
+        self._schedule = schedule
+
+    def __repr__(self) -> str:
+        """Return serializable representation of the class."""
+        return f"ScheduleDay({self._schedule})"
+
+    def __len__(self) -> int:
+        """Return a schedule length."""
+        return self._schedule.__len__()
+
+    def __iter__(self) -> Iterator[Time]:
+        """Return an iterator."""
+        return self._schedule.__iter__()
+
+    def __getitem__(self, time: Time) -> State:
+        """Return a schedule item."""
+        state = self._schedule.__getitem__(time)
+        return STATE_ON if state else STATE_OFF
+
+    def __delitem__(self, time: Time) -> None:
+        """Delete a schedule item."""
+        self._schedule.__delitem__(time)
+
+    def __setitem__(self, time: Time, state: State | bool) -> None:
+        """Set a schedule item."""
+        if state in get_args(State):
+            state = True if state == STATE_ON else False
+        if isinstance(state, bool):
+            self._schedule.__setitem__(time, state)
+        else:
+            raise TypeError(
+                f"Expected boolean value or one of: {', '.join(get_args(State))}."
+            )
+
+    def set_state(
+        self, state: State | bool, start: Time = MIDNIGHT, end: Time = MIDNIGHT
+    ) -> None:
+        """Set a schedule interval state."""
+        for time in get_time_range(start, end):
+            self.__setitem__(time, state)
+
+    def set_on(self, start: Time = MIDNIGHT, end: Time = MIDNIGHT) -> None:
+        """Set a schedule interval state to 'on'."""
+        self.set_state(STATE_ON, start, end)
+
+    def set_off(self, start: Time = MIDNIGHT, end: Time = MIDNIGHT) -> None:
+        """Set a schedule interval state to 'off'."""
+        self.set_state(STATE_OFF, start, end)
+
+    @property
+    def schedule(self) -> dict[Time, bool]:
+        """Return the schedule."""
+        return self._schedule
+
+    @classmethod
+    def from_iterable(cls: type[ScheduleDay], intervals: Iterable[bool]) -> ScheduleDay:
+        """Make schedule day from iterable."""
+        return cls({get_time(index): state for index, state in enumerate(intervals)})
+
+
+@dataclass
+class Schedule(Iterable):
+    """Represents a weekly schedule."""
+
+    __slots__ = (
+        "name",
+        "device",
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    )
+
+    name: str
+    device: PhysicalDevice
+
+    sunday: ScheduleDay
+    monday: ScheduleDay
+    tuesday: ScheduleDay
+    wednesday: ScheduleDay
+    thursday: ScheduleDay
+    friday: ScheduleDay
+    saturday: ScheduleDay
+
+    def __iter__(self) -> Iterator[ScheduleDay]:
+        """Return list of days."""
+        return (
+            self.sunday,
+            self.monday,
+            self.tuesday,
+            self.wednesday,
+            self.thursday,
+            self.friday,
+            self.saturday,
+        ).__iter__()
+
+    async def commit(self) -> None:
+        """Commit a weekly schedule to the device."""
+        await self.device.queue.put(
+            await Request.create(
+                FrameType.REQUEST_SET_SCHEDULE,
+                recipient=self.device.address,
+                data=collect_schedule_data(self.name, self.device),
+            )
+        )
+
+
 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))]
@@ -245,6 +412,8 @@ __all__ = [
     "ATTR_SCHEDULE_PARAMETERS",
     "ATTR_SCHEDULE_SWITCH",
     "ATTR_SCHEDULE_PARAMETER",
+    "Schedule",
+    "ScheduleDay",
     "ScheduleParameterDescription",
     "ScheduleParameter",
     "ScheduleNumberDescription",

{pyplumio-0.5.50.dist-info → pyplumio-0.5.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.50
+Version: 0.5.52
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,18 +25,18 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dataslots==1.2.0
 Requires-Dist: pyserial-asyncio==0.6
-Requires-Dist: typing-extensions==4.13.2
+Requires-Dist: typing-extensions==4.14.0
 Provides-Extra: test
 Requires-Dist: codespell==2.4.1; extra == "test"
-Requires-Dist: coverage==7.8.0; extra == "test"
-Requires-Dist: freezegun==1.5.1; extra == "test"
-Requires-Dist: mypy==1.15.0; extra == "test"
+Requires-Dist: coverage==7.9.1; extra == "test"
+Requires-Dist: freezegun==1.5.2; extra == "test"
+Requires-Dist: mypy==1.16.1; extra == "test"
 Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
-Requires-Dist: pytest==8.3.5; extra == "test"
-Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
-Requires-Dist: ruff==0.11.9; extra == "test"
-Requires-Dist: tox==4.25.0; extra == "test"
+Requires-Dist: pytest==8.4.1; extra == "test"
+Requires-Dist: pytest-asyncio==1.0.0; extra == "test"
+Requires-Dist: ruff==0.11.13; extra == "test"
+Requires-Dist: tox==4.26.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20250326; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"

{pyplumio-0.5.50.dist-info → pyplumio-0.5.52.dist-info}/RECORD

@@ -1,21 +1,21 @@
 pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=W2qdBOtSMf_VJh64HmusP_jxYyzDL0VrJZ_ZkeEZpKE,513
+pyplumio/_version.py,sha256=yGNU5eJ0S_ns8vdsPIX0Yq-JAj22V0bb0R9aJSWHpgE,513
 pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
-pyplumio/const.py,sha256=QIM5ueC8dx40Ccg1QHLI_mZ5wpBTptOofJWPdOOR7hk,5770
+pyplumio/const.py,sha256=eoq-WNJ8TO3YlP7dC7KkVQRKGjt9FbRZ6M__s29vb1U,5659
 pyplumio/data_types.py,sha256=r-QOIZiIpBFo4kRongyu8n0BHTaEU6wWMTmNkWBNjq8,9223
 pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
-pyplumio/filters.py,sha256=s35hmm8HxqktMOtNZMdXbqMeywBNKoIsAc5hWd0AEpk,15391
-pyplumio/protocol.py,sha256=9F_nkzsEuv6YWjuDyaoFH29dLaPBxeBxndogbWUG2jw,8337
+pyplumio/filters.py,sha256=8IPDa8GQLKf4OdoLwlTxFyffvZXt-VrE6nKpttMVTLg,15400
+pyplumio/protocol.py,sha256=DWM-yJnm2EQPLvGzXNlkQ0IpKQn44e-WkNB_DqZAag8,8313
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=iCB-XlNXRRE0p7nstb1AkXwVDwcCsgym_ggB_IDiJc8,4926
+pyplumio/stream.py,sha256=XzDZ1mkwUwy8wHtVII2W9t_8NpCQEwFmnlMeHwh8cd0,7832
 pyplumio/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
-pyplumio/devices/__init__.py,sha256=n0h2RwLxjm9YPjRoxURpMzVjfk2SP-GZQKJTcoMkxcc,8238
-pyplumio/devices/ecomax.py,sha256=5jc1dgWG8LCSeC4ZrQ9-hEYRsZB_N1i0V-L-aj0r0Is,16200
+pyplumio/devices/__init__.py,sha256=OLPY_Kk5E2SiJ4FLN2g6zmKQdQfutePV5jRH9kRHAMA,8260
+pyplumio/devices/ecomax.py,sha256=3_Hk6RaQ2e9WqIJ2NdPhofgVFjLbWIyR3TsRmMG35WY,16043
 pyplumio/devices/ecoster.py,sha256=X46ky5XT8jHMFq9sBW0ve8ZI_tjItQDMt4moXsW-ogY,307
 pyplumio/devices/mixer.py,sha256=7WdUVgwO4VXmaPNzh3ZWpKr2ooRXWemz2KFHAw35_Rk,2731
 pyplumio/devices/thermostat.py,sha256=MHMKe45fQ7jKlhBVObJ7McbYQKuF6-LOKSHy-9VNsCU,2253
-pyplumio/frames/__init__.py,sha256=5lw19oFlN89ZvO8KGwnkwERULQNYiP-hhZKk65LsjYY,7862
+pyplumio/frames/__init__.py,sha256=iHydFDClh3EDjElBis6nicNmF0QnahguBEtY_HOHsck,7885
 pyplumio/frames/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
 pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
 pyplumio/frames/responses.py,sha256=M6Ky4gg2AoShmRXX0x6nftajxrvmQLKPVRWbwyhvI0E,6663
@@ -23,18 +23,16 @@ pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,
 pyplumio/helpers/async_cache.py,sha256=EGQcU8LWJpVx3Hk6iaI-3mqAhnR5ACfBOGb9tWw-VSY,1305
 pyplumio/helpers/event_manager.py,sha256=aKNlhsPNTy3eOSfWVb9TJxtIsN9GAQv9XxhOi_BOhlM,8097
 pyplumio/helpers/factory.py,sha256=c3sitnkUjJWz7fPpTE9uRIpa8h46Qim3xsAblMw3eDo,1049
-pyplumio/helpers/schedule.py,sha256=ODNfMuqRZuFnnFxzFFvbE0sSQ6sxp4EUyxPMDBym-L0,5308
 pyplumio/helpers/task_manager.py,sha256=N71F6Ag1HHxdf5zJeCMcEziFdH9lmJKtMPoRGjJ-E40,1209
 pyplumio/helpers/timeout.py,sha256=2wAcOug-2TgdCchKbfv0VhAfNzP-MPM0TEFtRNFJ_m8,803
-pyplumio/helpers/uid.py,sha256=HeM5Zmd0qfNmVya6RKE-bBYzdxG-pAiViOZRHqw33VU,1011
-pyplumio/parameters/__init__.py,sha256=g9AWuCgEByGpLaiXRqE8f9xZ208ut2DNhEiDUJ0SJhs,14963
+pyplumio/parameters/__init__.py,sha256=2YTJJF-ehMLbPJwp02I1fycyLsatIXPSlTxXLwtkHtk,16054
 pyplumio/parameters/ecomax.py,sha256=4UqI7cokCt7qS9Du4-7JgLhM7mhHCHt8SWPl_qncmXQ,26239
 pyplumio/parameters/mixer.py,sha256=RjhfUU_62STyNV0Ud9A4G4FEvVwo02qGVl8h1QvqQXI,6646
 pyplumio/parameters/thermostat.py,sha256=-DK2Mb78CGrKmdhwAD0M3GiGJatczPnl1e2gVeT19tI,5070
-pyplumio/parameters/custom/__init__.py,sha256=tI_MXv0ExI8do7nPjA3oWiu0m0alGLlctggNNrgq09c,3240
-pyplumio/parameters/custom/ecomax_860d3_hb.py,sha256=DgPm-o2iOxveLR-2KTrf5xC9KRVJxBHK_3cQV4UNsEs,2860
+pyplumio/parameters/custom/__init__.py,sha256=o1khThLf4FMrjErFIcikAc6jI9gn5IyZlo7LNKKqJG4,3194
+pyplumio/parameters/custom/ecomax_860d3_hb.py,sha256=IsNgDXmV90QpBilDV4fGSBtIUEQJJbR9rjnfCr3-pHE,2840
 pyplumio/structures/__init__.py,sha256=emZVH5OFgdTUPbEJoznMKitmK0nlPm0I4SmF86It1Do,1345
-pyplumio/structures/alerts.py,sha256=fglFcxHoZ3hZJscPHmbJJqTr2mH8YXRW0T18L4Dirds,3692
+pyplumio/structures/alerts.py,sha256=Whl_WyHV9sXr321SuJAYBc1wUawNzi7xMZc41M8qToY,3724
 pyplumio/structures/boiler_load.py,sha256=e-6itp9L6iJeeOyhSTiOclHLuYmqG7KkcepsHwJSQSI,894
 pyplumio/structures/boiler_power.py,sha256=7CdOk-pYLEpy06oRBAeichvq8o-a2RcesB0tzo9ccBs,951
 pyplumio/structures/ecomax_parameters.py,sha256=E_s5bO0RqX8p1rM5DtYAsEXcHqS8P6Tg4AGm21cxsnM,1663
@@ -42,7 +40,7 @@ pyplumio/structures/fan_power.py,sha256=l9mDB_Ugnn1gKJFh9fppwzoi0i1_3eBvHAD6uPAd
 pyplumio/structures/frame_versions.py,sha256=n-L93poxY3i_l3oMWg0PzRXGrkY9cgv-Eyuf9XObaR4,1602
 pyplumio/structures/fuel_consumption.py,sha256=Cf3Z14gEZnkVEt-OAXNka3-T8fKIMHQaVSeQdQYXnPg,1034
 pyplumio/structures/fuel_level.py,sha256=-zUKApVJaZZzc1q52vqO3K2Mya43c6vRgw45d2xgy5Q,1123
-pyplumio/structures/lambda_sensor.py,sha256=0ZNEhzvNVtZt9CY0ZnZ7-N3fdWnuuexcrkztKq-lBSw,1708
+pyplumio/structures/lambda_sensor.py,sha256=09nM4Hwn1X275LzFpDihtpzkazwgJXAbx4NFqUkhbNM,1609
 pyplumio/structures/mixer_parameters.py,sha256=JMSySqI7TUGKdFtDp1P5DJm5EAbijMSz-orRrAe1KlQ,2041
 pyplumio/structures/mixer_sensors.py,sha256=ChgLhC3p4fyoPy1EKe0BQTvXOPZEISbcK2HyamrNaN8,2450
 pyplumio/structures/modules.py,sha256=LviFz3_pPvSQ5i_Mr2S9o5miVad8O4qn48CR_z7yG24,2791
@@ -50,17 +48,17 @@ pyplumio/structures/network_info.py,sha256=HYhROSMbVxqYxsOa7aF3xetQXEs0xGvhzH-4O
 pyplumio/structures/output_flags.py,sha256=upVIgAH2JNncHFXvjE-t6oTFF-JNwwZbyGjfrcKWtz0,1508
 pyplumio/structures/outputs.py,sha256=3NP5lArzQiihRC4QzBuWAHL9hhjvGxNkKmeoYZnDD-0,2291
 pyplumio/structures/pending_alerts.py,sha256=b1uMmDHTGv8eE0h1vGBrKsPxlwBmUad7HgChnDDLK_g,801
-pyplumio/structures/product_info.py,sha256=yXHFQv6LcA7kj8ErAY-fK4z33EIgDnvVDNe3Dccg_Bo,2472
+pyplumio/structures/product_info.py,sha256=Y5Q5UzKcxrixkB3Fd_BZaj1DdUNvUw1XASqR1oKMqn0,3308
 pyplumio/structures/program_version.py,sha256=qHmmPComCOa-dgq7cFAucEGuRS-jWYwWi40VCiPS7cc,2621
 pyplumio/structures/regulator_data.py,sha256=SYKI1YPC3mDAth-SpYejttbD0IzBfobjgC-uy_uUKnw,2333
 pyplumio/structures/regulator_data_schema.py,sha256=0SapbZCGzqAHmHC7dwhufszJ9FNo_ZO_XMrFGNiUe-w,1547
-pyplumio/structures/schedules.py,sha256=JWMyi-D_a2M8k17Zis7-o9L3Zn-Lvzdh1ewXDQeoaYo,7092
+pyplumio/structures/schedules.py,sha256=SGD9p12G_BVU2PSR1k5AS1cgx_bujFw8rqKSFohtEbc,12052
 pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8pLI,1325
 pyplumio/structures/temperatures.py,sha256=2VD3P_vwp9PEBkOn2-WhifOR8w-UYNq35aAxle0z2Vg,2831
 pyplumio/structures/thermostat_parameters.py,sha256=st3x3HkjQm3hqBrn_fpvPDQu8fuc-Sx33ONB19ViQak,3007
 pyplumio/structures/thermostat_sensors.py,sha256=rO9jTZWGQpThtJqVdbbv8sYMYHxJi4MfwZQza69L2zw,3399
-pyplumio-0.5.50.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.50.dist-info/METADATA,sha256=3cCn3n--0U3EccfpB_R7fKOwj2oX2w7bc4fyii4OzTg,5611
-pyplumio-0.5.50.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-pyplumio-0.5.50.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.50.dist-info/RECORD,,
+pyplumio-0.5.52.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.52.dist-info/METADATA,sha256=FMrf9h1q6n2yj7eafOP4MxGkRwTPEw3a0rMDi_xvyh4,5611
+pyplumio-0.5.52.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyplumio-0.5.52.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.52.dist-info/RECORD,,

{pyplumio-0.5.50.dist-info → pyplumio-0.5.52.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyplumio/helpers/schedule.py

@@ -1,180 +0,0 @@
-"""Contains a schedule helper classes."""
-
-from __future__ import annotations
-
-from collections.abc import Iterable, Iterator, MutableMapping
-from dataclasses import dataclass
-import datetime as dt
-from functools import lru_cache
-from typing import Annotated, Final, get_args
-
-from pyplumio.const import STATE_OFF, STATE_ON, FrameType, State
-from pyplumio.devices import PhysicalDevice
-from pyplumio.frames import Request
-from pyplumio.structures.schedules import collect_schedule_data
-
-TIME_FORMAT: Final = "%H:%M"
-
-
-Time = Annotated[str, "Time string in %H:%M format"]
-
-MIDNIGHT: Final = Time("00:00")
-MIDNIGHT_DT = dt.datetime.strptime(MIDNIGHT, TIME_FORMAT)
-
-STEP = dt.timedelta(minutes=30)
-
-
-def get_time(
-    index: int, start: dt.datetime = MIDNIGHT_DT, step: dt.timedelta = STEP
-) -> Time:
-    """Return time for a specific index."""
-    time_dt = start + (step * index)
-    return time_dt.strftime(TIME_FORMAT)
-
-
-@lru_cache(maxsize=10)
-def get_time_range(start: Time, end: Time, step: dt.timedelta = STEP) -> list[Time]:
-    """Get a time range.
-
-    Start and end boundaries should be specified in %H:%M format.
-    Both are inclusive.
-    """
-    start_dt = dt.datetime.strptime(start, TIME_FORMAT)
-    end_dt = dt.datetime.strptime(end, TIME_FORMAT)
-
-    if end_dt == MIDNIGHT_DT:
-        # Upper boundary of the interval is midnight.
-        end_dt += dt.timedelta(hours=24) - step
-
-    if end_dt <= start_dt:
-        raise ValueError(
-            f"Invalid time range: start time ({start}) must be earlier "
-            f"than end time ({end})."
-        )
-
-    seconds = (end_dt - start_dt).total_seconds()
-    steps = seconds // step.total_seconds() + 1
-
-    return [get_time(index, start=start_dt, step=step) for index in range(int(steps))]
-
-
-class ScheduleDay(MutableMapping):
-    """Represents a single day of schedule."""
-
-    __slots__ = ("_schedule",)
-
-    _schedule: dict[Time, bool]
-
-    def __init__(self, schedule: dict[Time, bool]) -> None:
-        """Initialize a new schedule day."""
-        self._schedule = schedule
-
-    def __repr__(self) -> str:
-        """Return serializable representation of the class."""
-        return f"ScheduleDay({self._schedule})"
-
-    def __len__(self) -> int:
-        """Return a schedule length."""
-        return self._schedule.__len__()
-
-    def __iter__(self) -> Iterator[Time]:
-        """Return an iterator."""
-        return self._schedule.__iter__()
-
-    def __getitem__(self, time: Time) -> State:
-        """Return a schedule item."""
-        state = self._schedule.__getitem__(time)
-        return STATE_ON if state else STATE_OFF
-
-    def __delitem__(self, time: Time) -> None:
-        """Delete a schedule item."""
-        self._schedule.__delitem__(time)
-
-    def __setitem__(self, time: Time, state: State | bool) -> None:
-        """Set a schedule item."""
-        if state in get_args(State):
-            state = True if state == STATE_ON else False
-        if isinstance(state, bool):
-            self._schedule.__setitem__(time, state)
-        else:
-            raise TypeError(
-                f"Expected boolean value or one of: {', '.join(get_args(State))}."
-            )
-
-    def set_state(
-        self, state: State | bool, start: Time = MIDNIGHT, end: Time = MIDNIGHT
-    ) -> None:
-        """Set a schedule interval state."""
-        for time in get_time_range(start, end):
-            self.__setitem__(time, state)
-
-    def set_on(self, start: Time = MIDNIGHT, end: Time = MIDNIGHT) -> None:
-        """Set a schedule interval state to 'on'."""
-        self.set_state(STATE_ON, start, end)
-
-    def set_off(self, start: Time = MIDNIGHT, end: Time = MIDNIGHT) -> None:
-        """Set a schedule interval state to 'off'."""
-        self.set_state(STATE_OFF, start, end)
-
-    @property
-    def schedule(self) -> dict[Time, bool]:
-        """Return the schedule."""
-        return self._schedule
-
-    @classmethod
-    def from_iterable(cls: type[ScheduleDay], intervals: Iterable[bool]) -> ScheduleDay:
-        """Make schedule day from iterable."""
-        return cls({get_time(index): state for index, state in enumerate(intervals)})
-
-
-@dataclass
-class Schedule(Iterable):
-    """Represents a weekly schedule."""
-
-    __slots__ = (
-        "name",
-        "device",
-        "sunday",
-        "monday",
-        "tuesday",
-        "wednesday",
-        "thursday",
-        "friday",
-        "saturday",
-    )
-
-    name: str
-    device: PhysicalDevice
-
-    sunday: ScheduleDay
-    monday: ScheduleDay
-    tuesday: ScheduleDay
-    wednesday: ScheduleDay
-    thursday: ScheduleDay
-    friday: ScheduleDay
-    saturday: ScheduleDay
-
-    def __iter__(self) -> Iterator[ScheduleDay]:
-        """Return list of days."""
-        return (
-            self.sunday,
-            self.monday,
-            self.tuesday,
-            self.wednesday,
-            self.thursday,
-            self.friday,
-            self.saturday,
-        ).__iter__()
-
-    async def commit(self) -> None:
-        """Commit a weekly schedule to the device."""
-        await self.device.queue.put(
-            await Request.create(
-                FrameType.REQUEST_SET_SCHEDULE,
-                recipient=self.device.address,
-                data=collect_schedule_data(self.name, self.device),
-            )
-        )
-
-
-__all__ = ["Schedule", "ScheduleDay"]

pyplumio/helpers/uid.py

@@ -1,44 +0,0 @@
-"""Contains UID helpers."""
-
-from __future__ import annotations
-
-from functools import reduce
-from typing import Final
-
-CRC: Final = 0xA3A3
-POLYNOMIAL: Final = 0xA001
-BASE5_KEY: Final = "0123456789ABCDEFGHIJKLMNZPQRSTUV"
-
-
-def unpack_uid(buffer: bytes) -> str:
-    """Unpack UID from bytes."""
-    return base5(buffer + crc16(buffer))
-
-
-def base5(buffer: bytes) -> str:
-    """Encode bytes to a base5 encoded string."""
-    number = int.from_bytes(buffer, byteorder="little")
-    output = []
-    while number:
-        output.append(BASE5_KEY[number & 0b00011111])
-        number >>= 5
-
-    return "".join(reversed(output))
-
-
-def crc16(buffer: bytes) -> bytes:
-    """Return a CRC 16."""
-    crc16 = reduce(crc16_byte, buffer, CRC)
-    return crc16.to_bytes(length=2, byteorder="little")
-
-
-def crc16_byte(crc: int, byte: int) -> int:
-    """Add a byte to the CRC."""
-    crc ^= byte
-    for _ in range(8):
-        crc = (crc >> 1) ^ POLYNOMIAL if crc & 1 else crc >> 1
-
-    return crc
-
-
-__all__ = ["unpack_uid"]