PyPlumIO 0.5.49__py3-none-any.whl → 0.5.51__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.49'
-__version_tuple__ = version_tuple = (0, 5, 49)
+__version__ = version = '0.5.51'
+__version_tuple__ = version_tuple = (0, 5, 51)

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."""
@@ -184,6 +177,7 @@ class FrameType(IntEnum):
     REQUEST_SET_MIXER_PARAMETER = 52
     REQUEST_SCHEDULES = 54
     REQUEST_SET_SCHEDULE = 55
+    REQUEST_ECOMAX_PARAMETER_CHANGES = 56
     REQUEST_UID = 57
     REQUEST_PASSWORD = 58
     REQUEST_ECOMAX_CONTROL = 59
@@ -203,6 +197,7 @@ class FrameType(IntEnum):
     RESPONSE_ECOMAX_CONTROL = 187
     RESPONSE_ALERTS = 189
     RESPONSE_PROGRAM_VERSION = 192
+    RESPONSE_ECOMAX_PARAMETER_CHANGES = 212
     RESPONSE_REGULATOR_DATA_SCHEMA = 213
     RESPONSE_THERMOSTAT_PARAMETERS = 220
     RESPONSE_SET_THERMOSTAT_PARAMETER = 221

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,
@@ -145,21 +145,26 @@ class PhysicalDevice(Device, ABC):
     @event_listener(filter=on_change)
     async def on_event_frame_versions(self, versions: dict[int, int]) -> None:
         """Check frame versions and update outdated frames."""
-        _LOGGER.info("Received frame version table")
+        _LOGGER.debug("Received frame version table")
         for frame_type, version in versions.items():
             if (
                 is_known_frame_type(frame_type)
                 and self.supports_frame_type(frame_type)
                 and not self.has_frame_version(frame_type, version)
             ):
-                await self._request_frame_version(frame_type, version)
+                request_frame_type = (
+                    FrameType.REQUEST_ECOMAX_PARAMETERS
+                    if frame_type == FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES
+                    else frame_type
+                )
+                await self._request_frame_version(request_frame_type, version)
                 self._frame_versions[frame_type] = version
 
     async def _request_frame_version(
         self, frame_type: FrameType | int, version: int
     ) -> None:
         """Request frame version from the device."""
-        _LOGGER.info("Updating frame %s to version %i", repr(frame_type), version)
+        _LOGGER.debug("Updating frame %s to version %i", repr(frame_type), version)
         request = await Request.create(frame_type, recipient=self.address)
         self.queue.put_nowait(request)
 

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,
@@ -234,7 +235,7 @@ class EcoMAX(PhysicalDevice):
     @event_listener
     async def on_event_setup(self, setup: bool) -> None:
         """Request frames required to set up an ecoMAX entry."""
-        _LOGGER.info("Setting up device entry")
+        _LOGGER.debug("Setting up device entry")
         await self.wait_for(ATTR_SENSORS)
         results = await asyncio.gather(
             *(
@@ -251,14 +252,14 @@ class EcoMAX(PhysicalDevice):
         if errors:
             self.dispatch_nowait(ATTR_FRAME_ERRORS, errors)
 
-        _LOGGER.info("Device entry setup done")
+        _LOGGER.debug("Device entry setup done")
 
     @event_listener
     async def on_event_ecomax_parameters(
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update ecoMAX parameters and dispatch the events."""
-        _LOGGER.info("Received device parameters")
+        _LOGGER.debug("Received device parameters")
         product_info: ProductInfo = await self.get(ATTR_PRODUCT)
         parameter_types = await get_ecomax_parameter_types(product_info)
 
@@ -303,11 +304,10 @@ 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.info("Received mixer parameters")
+        _LOGGER.debug("Received mixer parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -320,11 +320,9 @@ 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.info("Received mixer sensors")
+        _LOGGER.debug("Received mixer sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -364,7 +362,7 @@ class EcoMAX(PhysicalDevice):
     @event_listener
     async def on_event_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update ecoMAX sensors and dispatch the events."""
-        _LOGGER.info("Received device sensors")
+        _LOGGER.debug("Received device sensors")
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -372,11 +370,10 @@ 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.info("Received thermostat parameters")
+        _LOGGER.debug("Received thermostat parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -403,11 +400,9 @@ 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.info("Received thermostat sensors")
+        _LOGGER.debug("Received thermostat sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -427,7 +422,7 @@ class EcoMAX(PhysicalDevice):
         self, schedules: list[tuple[int, list[list[bool]]]]
     ) -> dict[str, Schedule]:
         """Update schedules."""
-        _LOGGER.info("Received device schedules")
+        _LOGGER.debug("Received device schedules")
         return {
             SCHEDULES[index]: Schedule(
                 name=SCHEDULES[index],

pyplumio/devices/mixer.py

@@ -29,7 +29,7 @@ class Mixer(VirtualDevice):
     @event_listener
     async def on_event_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update mixer sensors and dispatch the events."""
-        _LOGGER.info("Received mixer %i sensors", self.index)
+        _LOGGER.debug("Received mixer %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -40,7 +40,7 @@ class Mixer(VirtualDevice):
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update mixer parameters and dispatch the events."""
-        _LOGGER.info("Received mixer %i parameters", self.index)
+        _LOGGER.debug("Received mixer %i parameters", self.index)
         product_info: ProductInfo = await self.parent.get(ATTR_PRODUCT)
         parameter_types = get_mixer_parameter_types(product_info)
 

pyplumio/devices/thermostat.py

@@ -28,7 +28,7 @@ class Thermostat(VirtualDevice):
     @event_listener
     async def on_event_thermostat_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update thermostat sensors and dispatch the events."""
-        _LOGGER.info("Received thermostat %i sensors", self.index)
+        _LOGGER.debug("Received thermostat %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -39,7 +39,7 @@ class Thermostat(VirtualDevice):
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update thermostat parameters and dispatch the events."""
-        _LOGGER.info("Received thermostat %i parameters", self.index)
+        _LOGGER.debug("Received thermostat %i parameters", self.index)
         parameter_types = get_thermostat_parameter_types()
 
         def _thermostat_parameter_events() -> Generator[Coroutine]:

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/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,20 +230,17 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     @acache
     async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
         """Return the device entry."""
-
-        @acache
-        async def _setup_device_entry(device_type: DeviceType) -> PhysicalDevice:
-            """Set up the device entry."""
-            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)
-            self.dispatch_nowait(device_type.name.lower(), device)
-            return device
-
+        name = device_type.name.lower()
         async with self._entry_lock:
-            return await _setup_device_entry(device_type)
+            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(name, device)
+
+        return self.data[name]
 
 
 __all__ = ["Protocol", "DummyProtocol", "AsyncProtocol"]

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

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 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),
+            )
+        )
+
+
 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.49.dist-info → pyplumio-0.5.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.49
+Version: 0.5.51
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -35,8 +35,8 @@ 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: ruff==0.11.10; 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.49.dist-info → pyplumio-0.5.51.dist-info}/RECORD

@@ -1,20 +1,20 @@
 pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=u94vlma_2aQlFbifB92wUyxJiUQkXGcFrFlXXxDUYBA,513
+pyplumio/_version.py,sha256=GxxIjlMXqyiJ35TfmryleP4-ULoCRkGKYVM-gOVMu_0,513
 pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
-pyplumio/const.py,sha256=FxF97bl_GunYuB8Wo72zCzHtznRCM64ygC2qfaR3UyA,5684
+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=UnrXDouo4dDi7hqwJYHoEAvCoYJs3PgP1DFBBwRqBrw,8427
+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/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
-pyplumio/devices/__init__.py,sha256=frEoioDkJJuSGoBDlW42qxsRN_8lpzOvNJH56YQpd9E,7999
-pyplumio/devices/ecomax.py,sha256=-4rVUEg5MbzzoNXOFjp4cShsf4cqFh0mlIqlloZyWz4,16191
+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=q2UXMCQl6gueigHt-1Y1_P1sTEbBisZeQC75u2zAKmc,2729
-pyplumio/devices/thermostat.py,sha256=LBHJHfbkJgrwAifILk_IW_rRuDzSX1CDnA2xcLh4-NI,2251
+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/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
 pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
@@ -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=bhfFEICdwdNpIaP584cdDgfDA29s6knXMJAnu3tj_EQ,3688
 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=po-LFc3-Na6Rz9786fjBd9Gy3EDC1h6FKEmIM927ky8,12039
 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.49.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.49.dist-info/METADATA,sha256=dmnFwYN07jJBW5VBjNpme32Y7DbbAp1M9FPDn4AuRJA,5611
-pyplumio-0.5.49.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-pyplumio-0.5.49.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.49.dist-info/RECORD,,
+pyplumio-0.5.51.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.51.dist-info/METADATA,sha256=X9tX4ay9diGk9nUkp-MhZIVc5Ldc6F1FbvSWDNE985k,5612
+pyplumio-0.5.51.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+pyplumio-0.5.51.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.51.dist-info/RECORD,,

{pyplumio-0.5.49.dist-info → pyplumio-0.5.51.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.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"]