PyPlumIO 0.5.50__py3-none-any.whl → 0.5.51.post1__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.51.post1'
+__version_tuple__ = version_tuple = (0, 5, 51, 'post1')

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/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/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.50.dist-info → pyplumio-0.5.51.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.50
+Version: 0.5.51.post1
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -25,7 +25,7 @@ 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<5.0,>=4.14.0
 Provides-Extra: test
 Requires-Dist: codespell==2.4.1; extra == "test"
 Requires-Dist: coverage==7.8.0; extra == "test"
@@ -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.50.dist-info → pyplumio-0.5.51.post1.dist-info}/RECORD

@@ -1,17 +1,17 @@
 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=nacA7xVAM3pSgJxkdGVC41eusaq7HcO6tUp1yOrJlZY,528
 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/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
@@ -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.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.51.post1.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.51.post1.dist-info/METADATA,sha256=dDkVJmjdOWp3XDg_ybZ_zoIYLzYasSXStmvy_IhdP0E,5623
+pyplumio-0.5.51.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyplumio-0.5.51.post1.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.51.post1.dist-info/RECORD,,

{pyplumio-0.5.50.dist-info → pyplumio-0.5.51.post1.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"]