PyPlumIO 0.5.25__py3-none-any.whl → 0.5.26__py3-none-any.whl

pyplumio/helpers/event_manager.py

@@ -60,6 +60,7 @@ class EventManager(TaskManager, Generic[T]):
             become available, defaults to `None`
         :type timeout: float, optional
         :return: An event data
+        :rtype: T
         :raise asyncio.TimeoutError: when waiting past specified timeout
         """
         await self.wait_for(name, timeout=timeout)
@@ -81,8 +82,9 @@ class EventManager(TaskManager, Generic[T]):
         :type name: str
         :param default: default value to return if data is unavailable,
             defaults to `None`
-        :type default: Any, optional
+        :type default: T, optional
         :return: An event data
+        :rtype: T, optional
         """
         try:
             return self.data[name]
@@ -148,9 +150,9 @@ class EventManager(TaskManager, Generic[T]):
     async def dispatch(self, name: str, value: T) -> None:
         """Call registered callbacks and dispatch the event."""
         if callbacks := self._callbacks.get(name, None):
-            for callback in list(callbacks):
-                result = await callback(value)
-                value = result if result is not None else value
+            for callback in callbacks:
+                if (result := await callback(value)) is not None:
+                    value = result
 
         self.data[name] = value
         self.set_event(name)
@@ -181,9 +183,7 @@ class EventManager(TaskManager, Generic[T]):
     def set_event(self, name: str) -> None:
         """Set an event."""
         if name in self.events:
-            event = self.events[name]
-            if not event.is_set():
-                event.set()
+            self.events[name].set()
 
     @property
     def events(self) -> dict[str, asyncio.Event]:

pyplumio/helpers/factory.py

@@ -13,18 +13,17 @@ _LOGGER = logging.getLogger(__name__)
 T = TypeVar("T")
 
 
-async def _load_module(module_name: str) -> ModuleType:
-    """Load a module by name."""
-    return await asyncio.get_running_loop().run_in_executor(
-        None, importlib.import_module, f".{module_name}", "pyplumio"
-    )
+async def _import_module(name: str) -> ModuleType:
+    """Import module by name."""
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(None, importlib.import_module, f"pyplumio.{name}")
 
 
 async def create_instance(class_path: str, cls: type[T], **kwargs: Any) -> T:
     """Return a class instance from the class path."""
     module_name, class_name = class_path.rsplit(".", 1)
     try:
-        module = await _load_module(module_name)
+        module = await _import_module(module_name)
         instance = getattr(module, class_name)(**kwargs)
         if not isinstance(instance, cls):
             raise TypeError(f"class '{class_name}' should be derived from {cls}")

pyplumio/helpers/parameter.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 import asyncio
 from dataclasses import dataclass
 import logging
-from typing import TYPE_CHECKING, Any, Final, Literal, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union
 
 from dataslots import dataslots
 from typing_extensions import TypeAlias
@@ -19,10 +19,8 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
-SET_TIMEOUT: Final = 5
-SET_RETRIES: Final = 5
 
-ParameterValueType: TypeAlias = Union[int, float, bool, Literal["off", "on"]]
+ParameterValue: TypeAlias = Union[int, float, bool, Literal["off", "on"]]
 ParameterT = TypeVar("ParameterT", bound="Parameter")
 
 
@@ -49,7 +47,7 @@ def check_parameter(data: bytearray) -> bool:
     return any(x for x in data if x != BYTE_UNDEFINED)
 
 
-def _normalize_parameter_value(value: ParameterValueType) -> int:
+def _normalize_parameter_value(value: ParameterValue) -> int:
     """Normalize a parameter value."""
     if value in (STATE_OFF, STATE_ON):
         return 1 if value == STATE_ON else 0
@@ -177,7 +175,7 @@ class Parameter(ABC):
         )
         return type(self)(self.device, self.description, values)
 
-    async def set(self, value: Any, retries: int = SET_RETRIES) -> bool:
+    async def set(self, value: Any, retries: int = 5, timeout: float = 5.0) -> bool:
         """Set a parameter value."""
         if (value := _normalize_parameter_value(value)) == self.values.value:
             return True
@@ -198,7 +196,7 @@ class Parameter(ABC):
                 return False
 
             await self.device.queue.put(await self.create_request())
-            await asyncio.sleep(SET_TIMEOUT)
+            await asyncio.sleep(timeout)
             retries -= 1
 
         return True
@@ -272,13 +270,17 @@ class Number(Parameter):
 
     description: NumberDescription
 
-    async def set(self, value: int | float, retries: int = SET_RETRIES) -> bool:
+    async def set(
+        self, value: int | float, retries: int = 5, timeout: float = 5.0
+    ) -> bool:
         """Set a parameter value."""
-        return await super().set(value, retries)
+        return await super().set(value, retries, timeout)
 
-    def set_nowait(self, value: int | float, retries: int = SET_RETRIES) -> None:
+    def set_nowait(
+        self, value: int | float, retries: int = 5, timeout: float = 5.0
+    ) -> None:
         """Set a parameter value without waiting."""
-        self.device.create_task(self.set(value, retries))
+        self.device.create_task(self.set(value, retries, timeout))
 
     async def create_request(self) -> Request:
         """Create a request to change the number."""
@@ -319,16 +321,16 @@ class Switch(Parameter):
     description: SwitchDescription
 
     async def set(
-        self, value: bool | Literal["off", "on"], retries: int = SET_RETRIES
+        self, value: bool | Literal["off", "on"], retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
-        return await super().set(value, retries)
+        return await super().set(value, retries, timeout)
 
     def set_nowait(
-        self, value: bool | Literal["off", "on"], retries: int = SET_RETRIES
+        self, value: bool | Literal["off", "on"], retries: int = 5, timeout: float = 5.0
     ) -> None:
         """Set a switch value without waiting."""
-        self.device.create_task(self.set(value, retries))
+        self.device.create_task(self.set(value, retries, timeout))
 
     async def turn_on(self) -> bool:
         """Set a switch value to 'on'.

pyplumio/helpers/schedule.py

@@ -2,53 +2,65 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable, Iterator, MutableMapping
+from collections.abc import Generator, Iterable, Iterator, MutableMapping
 from dataclasses import dataclass
 import datetime as dt
 from functools import lru_cache
 import math
-from typing import Final, Literal
+from typing import Annotated, Final, Literal, get_args
+
+from typing_extensions import TypeAlias
 
 from pyplumio.const import STATE_OFF, STATE_ON, FrameType
-from pyplumio.devices import AddressableDevice
+from pyplumio.devices import PhysicalDevice
 from pyplumio.frames import Request
 from pyplumio.structures.schedules import collect_schedule_data
 
 TIME_FORMAT: Final = "%H:%M"
-START_OF_DAY: Final = "00:00"
-END_OF_DAY: Final = "00:00"
 
 STATE_NIGHT: Final = "night"
 STATE_DAY: Final = "day"
 
 ON_STATES: Final = (STATE_ON, STATE_DAY)
 OFF_STATES: Final = (STATE_OFF, STATE_NIGHT)
-ALLOWED_STATES: Final = ON_STATES + OFF_STATES
 
+ScheduleState: TypeAlias = Literal["on", "off", "day", "night"]
+Time = Annotated[str, "time in HH:MM format"]
+
+start_of_day_dt = dt.datetime.strptime("00:00", TIME_FORMAT)
 
-@lru_cache(maxsize=10)
-def _parse_interval(start: str, end: str) -> tuple[int, int]:
-    """Parse an interval string.
 
-    Intervals should be specified in '%H:%M' format.
+def _get_time_range(
+    start: Time, end: Time, step: int = 30
+) -> Generator[int, None, None]:
+    """Get a time range.
+
+    Start and end times should be specified in HH:MM format, step in
+    minutes.
     """
-    start_dt = dt.datetime.strptime(start, TIME_FORMAT)
-    end_dt = dt.datetime.strptime(end, TIME_FORMAT)
-    start_of_day_dt = dt.datetime.strptime(START_OF_DAY, TIME_FORMAT)
-    if end_dt == start_of_day_dt:
-        # Upper bound of interval is midnight.
-        end_dt += dt.timedelta(hours=23, minutes=30)
-
-    if end_dt <= start_dt:
-        raise ValueError(
-            f"Invalid interval ({start}, {end}). "
-            + "Lower boundary must be less than upper."
-        )
 
-    start_index = math.floor((start_dt - start_of_day_dt).total_seconds() // (60 * 30))
-    end_index = math.floor((end_dt - start_of_day_dt).total_seconds() // (60 * 30))
+    @lru_cache(maxsize=10)
+    def _get_time_range_cached(start: Time, end: Time, step: int = 30) -> range:
+        """Get a time range and cache it using LRU cache."""
+        start_dt = dt.datetime.strptime(start, TIME_FORMAT)
+        end_dt = dt.datetime.strptime(end, TIME_FORMAT)
+        if end_dt == start_of_day_dt:
+            # Upper boundary of the interval is midnight.
+            end_dt += dt.timedelta(hours=24) - dt.timedelta(minutes=step)
+
+        if end_dt <= start_dt:
+            raise ValueError(
+                f"Invalid interval ({start}, {end}). "
+                "Lower boundary must be less than upper."
+            )
+
+        def _dt_to_index(dt: dt.datetime) -> int:
+            """Convert datetime to index in schedule list."""
+            return math.floor((dt - start_of_day_dt).total_seconds() // (60 * step))
+
+        return range(_dt_to_index(start_dt), _dt_to_index(end_dt) + 1)
 
-    return start_index, end_index
+    yield from _get_time_range_cached(start, end, step)
 
 
 class ScheduleDay(MutableMapping):
@@ -91,30 +103,21 @@ class ScheduleDay(MutableMapping):
         self._intervals.append(item)
 
     def set_state(
-        self,
-        state: Literal["on", "off", "day", "night"],
-        start: str = START_OF_DAY,
-        end: str = END_OF_DAY,
+        self, state: ScheduleState, start: Time = "00:00", end: Time = "00:00"
     ) -> None:
-        """Set an interval state.
-
-        Can be on of the following:
-        'on', 'off', 'day' or 'night'.
-        """
-        if state not in ALLOWED_STATES:
+        """Set a schedule interval state."""
+        if state not in get_args(ScheduleState):
             raise ValueError(f'state "{state}" is not allowed')
 
-        index, end_index = _parse_interval(start, end)
-        while index <= end_index:
-            self._intervals[index] = state in ON_STATES
-            index += 1
+        for index in _get_time_range(start, end):
+            self._intervals[index] = True if state in ON_STATES else False
 
-    def set_on(self, start: str = START_OF_DAY, end: str = END_OF_DAY) -> None:
-        """Set an interval state to 'on'."""
+    def set_on(self, start: Time = "00:00", end: Time = "00:00") -> None:
+        """Set a schedule interval state to 'on'."""
         self.set_state(STATE_ON, start, end)
 
-    def set_off(self, start: str = START_OF_DAY, end: str = END_OF_DAY) -> None:
-        """Set an interval state to 'off'."""
+    def set_off(self, start: Time = "00:00", end: Time = "00:00") -> None:
+        """Set a schedule interval state to 'off'."""
         self.set_state(STATE_OFF, start, end)
 
     @property
@@ -130,24 +133,25 @@ class Schedule(Iterable):
     __slots__ = (
         "name",
         "device",
+        "sunday",
         "monday",
         "tuesday",
         "wednesday",
         "thursday",
         "friday",
         "saturday",
-        "sunday",
     )
 
     name: str
-    device: AddressableDevice
+    device: PhysicalDevice
+
+    sunday: ScheduleDay
     monday: ScheduleDay
     tuesday: ScheduleDay
     wednesday: ScheduleDay
     thursday: ScheduleDay
     friday: ScheduleDay
     saturday: ScheduleDay
-    sunday: ScheduleDay
 
     def __iter__(self) -> Iterator[ScheduleDay]:
         """Return list of days."""

pyplumio/helpers/timeout.py

@@ -14,7 +14,7 @@ P = ParamSpec("P")
 
 
 def timeout(
-    seconds: int,
+    seconds: float,
 ) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Coroutine[Any, Any, T]]]:
     """Decorate a timeout for the awaitable."""
 

pyplumio/protocol.py

@@ -11,7 +11,7 @@ import logging
 from typing_extensions import TypeAlias
 
 from pyplumio.const import ATTR_CONNECTED, DeviceType
-from pyplumio.devices import AddressableDevice
+from pyplumio.devices import PhysicalDevice
 from pyplumio.exceptions import ProtocolError
 from pyplumio.frames import Frame
 from pyplumio.frames.requests import StartMasterRequest
@@ -113,7 +113,7 @@ class Queues:
         await asyncio.gather(self.read.join(), self.write.join())
 
 
-class AsyncProtocol(Protocol, EventManager[AddressableDevice]):
+class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     """Represents an async protocol.
 
     This protocol implements producer-consumers pattern using
@@ -204,7 +204,7 @@ class AsyncProtocol(Protocol, EventManager[AddressableDevice]):
                     await writer.write(await queues.write.get())
                     queues.write.task_done()
 
-                if (response := await reader.read()) is not None:
+                if response := await reader.read():
                     queues.read.put_nowait(response)
 
             except ProtocolError as e:
@@ -224,16 +224,15 @@ class AsyncProtocol(Protocol, EventManager[AddressableDevice]):
             device.handle_frame(frame)
             queue.task_done()
 
-    async def get_device_entry(self, device_type: DeviceType) -> AddressableDevice:
+    async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
         """Set up or return a device entry."""
         name = device_type.name.lower()
         if name not in self.data:
-            device = await AddressableDevice.create(
+            device = await PhysicalDevice.create(
                 device_type, queue=self._queues.write, network=self._network
             )
             device.dispatch_nowait(ATTR_CONNECTED, True)
             self.create_task(device.async_setup(), name=f"device_setup_task ({name})")
-            self.set_event(name)
-            self.data[name] = device
+            await self.dispatch(name, device)
 
         return self.data[name]

pyplumio/structures/alerts.py

@@ -76,12 +76,13 @@ class AlertsStructure(StructureDecoder):
 
     def _unpack_alert(self, message: bytearray) -> Alert:
         """Unpack an alert."""
-        code = message[self._offset]
-        self._offset += 1
-        from_seconds = UnsignedInt.from_bytes(message, self._offset)
-        self._offset += from_seconds.size
-        to_seconds = UnsignedInt.from_bytes(message, self._offset)
-        self._offset += to_seconds.size
+        offset = self._offset
+        code = message[offset]
+        offset += 1
+        from_seconds = UnsignedInt.from_bytes(message, offset)
+        offset += from_seconds.size
+        to_seconds = UnsignedInt.from_bytes(message, offset)
+        offset += to_seconds.size
         from_dt = _seconds_to_datetime(from_seconds.value)
         to_dt = (
             None
@@ -91,6 +92,7 @@ class AlertsStructure(StructureDecoder):
         with suppress(ValueError):
             code = AlertType(code)
 
+        self._offset = offset
         return Alert(code, from_dt, to_dt)
 
     def decode(

pyplumio/structures/ecomax_parameters.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Generator
 from dataclasses import dataclass
+from functools import partial
 from typing import Any, Final
 
 from dataslots import dataslots
@@ -18,10 +19,9 @@ from pyplumio.const import (
     ProductType,
     UnitOfMeasurement,
 )
-from pyplumio.devices import AddressableDevice
+from pyplumio.devices import PhysicalDevice
 from pyplumio.frames import Request
 from pyplumio.helpers.parameter import (
-    SET_TIMEOUT,
     Number,
     NumberDescription,
     Parameter,
@@ -47,41 +47,40 @@ class EcomaxParameterDescription(ParameterDescription):
 
     __slots__ = ()
 
-    multiplier: float = 1.0
-    offset: int = 0
-
 
 class EcomaxParameter(Parameter):
     """Represents an ecoMAX parameter."""
 
     __slots__ = ()
 
-    device: AddressableDevice
+    device: PhysicalDevice
     description: EcomaxParameterDescription
 
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
+        handler = partial(Request.create, recipient=self.device.address)
         if self.description.name == ATTR_ECOMAX_CONTROL:
-            frame_type = FrameType.REQUEST_ECOMAX_CONTROL
-            data = {ATTR_VALUE: self.values.value}
+            request = await handler(
+                frame_type=FrameType.REQUEST_ECOMAX_CONTROL,
+                data={ATTR_VALUE: self.values.value},
+            )
         elif self.description.name == ATTR_THERMOSTAT_PROFILE:
-            frame_type = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
-            data = {
-                ATTR_INDEX: self._index,
-                ATTR_VALUE: self.values.value,
-                ATTR_OFFSET: 0,
-                ATTR_SIZE: 1,
-            }
+            request = await handler(
+                frame_type=FrameType.REQUEST_SET_THERMOSTAT_PARAMETER,
+                data={
+                    ATTR_INDEX: self._index,
+                    ATTR_VALUE: self.values.value,
+                    ATTR_OFFSET: 0,
+                    ATTR_SIZE: 1,
+                },
+            )
         else:
-            frame_type = FrameType.REQUEST_SET_ECOMAX_PARAMETER
-            data = {
-                ATTR_INDEX: self._index,
-                ATTR_VALUE: self.values.value,
-            }
-
-        return await Request.create(
-            frame_type, recipient=self.device.address, data=data
-        )
+            request = await handler(
+                frame_type=FrameType.REQUEST_SET_ECOMAX_PARAMETER,
+                data={ATTR_INDEX: self._index, ATTR_VALUE: self.values.value},
+            )
+
+        return request
 
 
 @dataslots
@@ -89,6 +88,9 @@ class EcomaxParameter(Parameter):
 class EcomaxNumberDescription(EcomaxParameterDescription, NumberDescription):
     """Represents an ecoMAX number description."""
 
+    multiplier: float = 1.0
+    offset: int = 0
+
 
 class EcomaxNumber(EcomaxParameter, Number):
     """Represents a ecoMAX number."""
@@ -97,10 +99,12 @@ class EcomaxNumber(EcomaxParameter, Number):
 
     description: EcomaxNumberDescription
 
-    async def set(self, value: float | int, retries: int = SET_TIMEOUT) -> bool:
+    async def set(
+        self, value: float | int, retries: int = 5, timeout: float = 5.0
+    ) -> bool:
         """Set a parameter value."""
         value = (value + self.description.offset) / self.description.multiplier
-        return await super().set(value, retries)
+        return await super().set(value, retries, timeout)
 
     @property
     def value(self) -> float:

pyplumio/structures/frame_versions.py

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

pyplumio/structures/mixer_parameters.py

@@ -18,7 +18,6 @@ from pyplumio.const import (
 )
 from pyplumio.frames import Request
 from pyplumio.helpers.parameter import (
-    SET_RETRIES,
     Number,
     NumberDescription,
     Parameter,
@@ -45,9 +44,6 @@ class MixerParameterDescription(ParameterDescription):
 
     __slots__ = ()
 
-    multiplier: float = 1.0
-    offset: int = 0
-
 
 class MixerParameter(Parameter):
     """Represent a mixer parameter."""
@@ -75,6 +71,9 @@ class MixerParameter(Parameter):
 class MixerNumberDescription(MixerParameterDescription, NumberDescription):
     """Represent a mixer number description."""
 
+    multiplier: float = 1.0
+    offset: int = 0
+
 
 class MixerNumber(MixerParameter, Number):
     """Represents a mixer number."""
@@ -83,10 +82,12 @@ class MixerNumber(MixerParameter, Number):
 
     description: MixerNumberDescription
 
-    async def set(self, value: int | float, retries: int = SET_RETRIES) -> bool:
+    async def set(
+        self, value: int | float, retries: int = 5, timeout: float = 5.0
+    ) -> bool:
         """Set a parameter value."""
         value = (value + self.description.offset) / self.description.multiplier
-        return await super().set(value, retries)
+        return await super().set(value, retries, timeout)
 
     @property
     def value(self) -> float:
@@ -264,6 +265,8 @@ MIXER_PARAMETERS: dict[ProductType, tuple[MixerParameterDescription, ...]] = {
 class MixerParametersStructure(StructureDecoder):
     """Represents a mixer parameters data structure."""
 
+    __slots__ = ("_offset",)
+
     _offset: int
 
     def _mixer_parameter(

pyplumio/structures/mixer_sensors.py

@@ -28,18 +28,20 @@ class MixerSensorsStructure(StructureDecoder):
 
     def _unpack_mixer_sensors(self, message: bytearray) -> dict[str, Any] | None:
         """Unpack sensors for a mixer."""
-        current_temp = Float.from_bytes(message, self._offset)
+        offset = self._offset
+        current_temp = Float.from_bytes(message, offset)
         try:
-            if not math.isnan(current_temp.value):
-                return {
+            return (
+                {
                     ATTR_CURRENT_TEMP: current_temp.value,
-                    ATTR_TARGET_TEMP: message[self._offset + 4],
-                    ATTR_PUMP: bool(message[self._offset + 6] & 0x01),
+                    ATTR_TARGET_TEMP: message[offset + 4],
+                    ATTR_PUMP: bool(message[offset + 6] & 0x01),
                 }
-
-            return None
+                if not math.isnan(current_temp.value)
+                else None
+            )
         finally:
-            self._offset += MIXER_SENSOR_SIZE
+            self._offset = offset + MIXER_SENSOR_SIZE
 
     def _mixer_sensors(
         self, message: bytearray, mixers: int

pyplumio/structures/modules.py

@@ -6,6 +6,8 @@ from dataclasses import dataclass
 import struct
 from typing import Any, Final
 
+from dataslots import dataslots
+
 from pyplumio.const import BYTE_UNDEFINED
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
@@ -30,6 +32,7 @@ struct_version = struct.Struct("<BBB")
 struct_vendor = struct.Struct("<BB")
 
 
+@dataslots
 @dataclass
 class ConnectedModules:
     """Represents a firmware version info for connected module."""
@@ -55,17 +58,16 @@ class ModulesStructure(StructureDecoder):
             self._offset += 1
             return None
 
-        version_data = struct_version.unpack_from(message, self._offset)
+        offset = self._offset
+        version_data = struct_version.unpack_from(message, offset)
         version = ".".join(str(i) for i in version_data)
-        self._offset += struct_version.size
-
+        offset += struct_version.size
         if module == ATTR_MODULE_A:
-            vendor_code, vendor_version = struct_vendor.unpack_from(
-                message, self._offset
-            )
+            vendor_code, vendor_version = struct_vendor.unpack_from(message, offset)
             version += f".{chr(vendor_code) + str(vendor_version)}"
-            self._offset += struct_vendor.size
+            offset += struct_vendor.size
 
+        self._offset = offset
         return version
 
     def decode(