PyPlumIO 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

pyplumio/frames/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from collections.abc import Callable
 from functools import cache, reduce
 import struct
 from typing import TYPE_CHECKING, Any, ClassVar, Final, TypeVar
@@ -13,6 +13,9 @@ from pyplumio.exceptions import UnknownFrameError
 from pyplumio.helpers.factory import create_instance
 from pyplumio.utils import ensure_dict, to_camelcase
 
+if TYPE_CHECKING:
+    from pyplumio.structures import Structure
+
 FRAME_START: Final = 0x68
 FRAME_END: Final = 0x16
 
@@ -60,15 +63,7 @@ def get_frame_handler(frame_type: int) -> str:
     return f"frames.{module.lower()}s.{type_name}{module.capitalize()}"
 
 
-@dataclass(slots=True)
-class DataFrameDescription:
-    """Describes what data is provided by the frame."""
-
-    frame_type: FrameType
-    provides: str
-
-
-FrameT = TypeVar("FrameT", bound="Frame")
+_FrameT = TypeVar("_FrameT", bound="Frame")
 
 
 class Frame(ABC):
@@ -235,17 +230,17 @@ class Frame(ABC):
         return bytes(data)
 
     @classmethod
-    async def create(cls: type[FrameT], frame_type: int, **kwargs: Any) -> FrameT:
+    async def create(cls: type[_FrameT], frame_type: int, **kwargs: Any) -> _FrameT:
         """Create a frame handler object from frame type."""
         return await create_instance(get_frame_handler(frame_type), cls=cls, **kwargs)
 
     @abstractmethod
     def create_message(self, data: dict[str, Any]) -> bytearray:
-        """Create frame message."""
+        """Create a frame message."""
 
     @abstractmethod
     def decode_message(self, message: bytearray) -> dict[str, Any]:
-        """Decode frame message."""
+        """Decode a frame message."""
 
 
 class Request(Frame):
@@ -286,13 +281,104 @@ class Message(Response):
     __slots__ = ()
 
 
+class Structured(Frame):
+    """Represents a frame that has known structure."""
+
+    __slots__ = ("_structures",)
+
+    container: ClassVar[str]
+    structures: ClassVar[list[type[Structure]]]
+
+    _structures: list[Structure]
+
+    def __init__(
+        self,
+        recipient: DeviceType = DeviceType.ALL,
+        sender: DeviceType = DeviceType.ECONET,
+        econet_type: int = ECONET_TYPE,
+        econet_version: int = ECONET_VERSION,
+        message: bytearray | None = None,
+        data: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize a new structured frame."""
+        if hasattr(self, "structures"):
+            self._structures = [structure(self) for structure in self.structures]
+
+        super().__init__(
+            recipient, sender, econet_type, econet_version, message, data, **kwargs
+        )
+
+    def create_message(self, data: dict[str, Any]) -> bytearray:
+        """Create frame message."""
+        message = bytearray()
+        for structure in self._structures:
+            message += structure.encode(data)
+
+        return message
+
+    def decode_message(self, message: bytearray) -> dict[str, Any]:
+        """Decode frame message."""
+        data: dict[str, Any] = {}
+        offset = 0
+        for structure in self._structures:
+            data, offset = structure.decode(message, offset, data)
+
+        if hasattr(self, "container"):
+            return {self.container: data}
+
+        return data
+
+
+def frame_handler(
+    frame_type: FrameType, structure: type[Structure] | None = None
+) -> Callable[[type[_FrameT]], type[_FrameT]]:
+    """Specify frame type for the frame class."""
+
+    def wrapper(cls: type[_FrameT]) -> type[_FrameT]:
+        """Wrap the frame class."""
+        setattr(cls, "frame_type", frame_type)
+        if structure and issubclass(cls, Structured):
+            setattr(cls, "structures", (structure,))
+
+        return cls
+
+    return wrapper
+
+
+_StructuredT = TypeVar("_StructuredT", bound=Structured)
+
+
+def contains(
+    *structures: type[Structure], container: str | None = None
+) -> Callable[[type[_StructuredT]], type[_StructuredT]]:
+    """Decorate frame class with structure.
+
+    Indicate which structures need to be used for encoding/decoding
+    the frame as well as provide a way to wrap output data under
+    a single key.
+    """
+
+    def wrapper(cls: type[_StructuredT]) -> type[_StructuredT]:
+        """Wrap the frame class."""
+        setattr(cls, "structures", structures)
+        if container:
+            setattr(cls, "container", container)
+
+        return cls
+
+    return wrapper
+
+
 __all__ = [
     "Frame",
     "Request",
     "Response",
     "Message",
-    "DataFrameDescription",
+    "Structured",
     "bcc",
-    "is_known_frame_type",
+    "contains",
+    "frame_handler",
     "get_frame_handler",
+    "is_known_frame_type",
 ]

pyplumio/frames/messages.py

@@ -2,83 +2,26 @@
 
 from __future__ import annotations
 
-from contextlib import suppress
-from typing import Any
-
-from pyplumio.const import (
-    ATTR_SENSORS,
-    ATTR_STATE,
-    ATTR_THERMOSTAT,
-    ATTR_TRANSMISSION,
-    DeviceState,
-    FrameType,
-)
-from pyplumio.frames import Message
-from pyplumio.structures.boiler_load import BoilerLoadStructure
-from pyplumio.structures.boiler_power import BoilerPowerStructure
-from pyplumio.structures.fan_power import FanPowerStructure
+from pyplumio.const import ATTR_SENSORS, FrameType
+from pyplumio.frames import Message, Structured, contains, frame_handler
 from pyplumio.structures.frame_versions import FrameVersionsStructure
-from pyplumio.structures.fuel_consumption import FuelConsumptionStructure
-from pyplumio.structures.fuel_level import FuelLevelStructure
-from pyplumio.structures.lambda_sensor import LambdaSensorStructure
-from pyplumio.structures.mixer_sensors import MixerSensorsStructure
-from pyplumio.structures.modules import ModulesStructure
-from pyplumio.structures.output_flags import OutputFlagsStructure
-from pyplumio.structures.outputs import OutputsStructure
-from pyplumio.structures.pending_alerts import PendingAlertsStructure
 from pyplumio.structures.regulator_data import RegulatorDataStructure
-from pyplumio.structures.statuses import StatusesStructure
-from pyplumio.structures.temperatures import TemperaturesStructure
-from pyplumio.structures.thermostat_sensors import ThermostatSensorsStructure
+from pyplumio.structures.sensor_data import SensorDataStructure
 
 
-class RegulatorDataMessage(Message):
+@frame_handler(FrameType.MESSAGE_REGULATOR_DATA, structure=RegulatorDataStructure)
+class RegulatorDataMessage(Structured, Message):
     """Represents a regulator data message."""
 
     __slots__ = ()
 
-    frame_type = FrameType.MESSAGE_REGULATOR_DATA
-
-    def decode_message(self, message: bytearray) -> dict[str, Any]:
-        """Decode a frame message."""
-        return RegulatorDataStructure(self).decode(message)[0]
-
 
-class SensorDataMessage(Message):
+@frame_handler(FrameType.MESSAGE_SENSOR_DATA)
+@contains(FrameVersionsStructure, SensorDataStructure, container=ATTR_SENSORS)
+class SensorDataMessage(Structured, Message):
     """Represents a sensor data message."""
 
     __slots__ = ()
 
-    frame_type = FrameType.MESSAGE_SENSOR_DATA
-
-    def decode_message(self, message: bytearray) -> dict[str, Any]:
-        """Decode a frame message."""
-        sensors, offset = FrameVersionsStructure(self).decode(message, offset=0)
-        sensors[ATTR_STATE] = message[offset]
-        sensors, offset = OutputsStructure(self).decode(message, offset + 1, sensors)
-        sensors, offset = OutputFlagsStructure(self).decode(message, offset, sensors)
-        sensors, offset = TemperaturesStructure(self).decode(message, offset, sensors)
-        sensors, offset = StatusesStructure(self).decode(message, offset, sensors)
-        sensors, offset = PendingAlertsStructure(self).decode(message, offset, sensors)
-        sensors, offset = FuelLevelStructure(self).decode(message, offset, sensors)
-        sensors[ATTR_TRANSMISSION] = message[offset]
-        sensors, offset = FanPowerStructure(self).decode(message, offset + 1, sensors)
-        sensors, offset = BoilerLoadStructure(self).decode(message, offset, sensors)
-        sensors, offset = BoilerPowerStructure(self).decode(message, offset, sensors)
-        sensors, offset = FuelConsumptionStructure(self).decode(
-            message, offset, sensors
-        )
-        sensors[ATTR_THERMOSTAT] = message[offset]
-        sensors, offset = ModulesStructure(self).decode(message, offset + 1, sensors)
-        sensors, offset = LambdaSensorStructure(self).decode(message, offset, sensors)
-        sensors, offset = ThermostatSensorsStructure(self).decode(
-            message, offset, sensors
-        )
-        sensors, offset = MixerSensorsStructure(self).decode(message, offset, sensors)
-        with suppress(ValueError):
-            sensors[ATTR_STATE] = DeviceState(sensors[ATTR_STATE])
-
-        return {ATTR_SENSORS: sensors}
-
 
 __all__ = ["RegulatorDataMessage", "SensorDataMessage"]

pyplumio/frames/requests.py

@@ -2,24 +2,30 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, cast
 
 from pyplumio.const import (
     ATTR_COUNT,
     ATTR_DEVICE_INDEX,
     ATTR_INDEX,
     ATTR_OFFSET,
+    ATTR_PARAMETER,
+    ATTR_SCHEDULE,
     ATTR_SIZE,
     ATTR_START,
+    ATTR_SWITCH,
+    ATTR_TYPE,
     ATTR_VALUE,
     FrameType,
 )
 from pyplumio.exceptions import FrameDataError
-from pyplumio.frames import Request, Response
+from pyplumio.frames import Request, Response, frame_handler
 from pyplumio.frames.responses import DeviceAvailableResponse, ProgramVersionResponse
-from pyplumio.structures.schedules import SchedulesStructure
+from pyplumio.structures.schedules import SCHEDULES
+from pyplumio.utils import join_bits
 
 
+@frame_handler(FrameType.REQUEST_ALERTS)
 class AlertsRequest(Request):
     """Represents an alerts request.
 
@@ -29,25 +35,23 @@ class AlertsRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_ALERTS
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         return bytearray([data.get(ATTR_START, 0), data.get(ATTR_COUNT, 10)])
 
 
+@frame_handler(FrameType.REQUEST_CHECK_DEVICE)
 class CheckDeviceRequest(Request):
     """Represents a check device request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_CHECK_DEVICE
-
     def response(self, **kwargs: Any) -> Response | None:
         """Return a response frame."""
         return DeviceAvailableResponse(recipient=self.sender, **kwargs)
 
 
+@frame_handler(FrameType.REQUEST_ECOMAX_CONTROL)
 class EcomaxControlRequest(Request):
     """Represents an ecoMAX control request.
 
@@ -57,8 +61,6 @@ class EcomaxControlRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_ECOMAX_CONTROL
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         try:
@@ -67,6 +69,7 @@ class EcomaxControlRequest(Request):
             raise FrameDataError from e
 
 
+@frame_handler(FrameType.REQUEST_ECOMAX_PARAMETERS)
 class EcomaxParametersRequest(Request):
     """Represents an ecoMAX parameters request.
 
@@ -75,13 +78,12 @@ class EcomaxParametersRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_ECOMAX_PARAMETERS
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_START, 0)])
 
 
+@frame_handler(FrameType.REQUEST_MIXER_PARAMETERS)
 class MixerParametersRequest(Request):
     """Represents a mixer parameters request.
 
@@ -91,49 +93,44 @@ class MixerParametersRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_MIXER_PARAMETERS
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_START, 0)])
 
 
+@frame_handler(FrameType.REQUEST_PASSWORD)
 class PasswordRequest(Request):
     """Represents a password request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_PASSWORD
-
 
+@frame_handler(FrameType.REQUEST_PROGRAM_VERSION)
 class ProgramVersionRequest(Request):
     """Represents a program version request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_PROGRAM_VERSION
-
     def response(self, **kwargs: Any) -> Response | None:
         """Return a response frame."""
         return ProgramVersionResponse(recipient=self.sender, **kwargs)
 
 
+@frame_handler(FrameType.REQUEST_REGULATOR_DATA_SCHEMA)
 class RegulatorDataSchemaRequest(Request):
     """Represents regulator data schema request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_REGULATOR_DATA_SCHEMA
-
 
+@frame_handler(FrameType.REQUEST_SCHEDULES)
 class SchedulesRequest(Request):
     """Represents a schedules request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_SCHEDULES
-
 
+@frame_handler(FrameType.REQUEST_SET_ECOMAX_PARAMETER)
 class SetEcomaxParameterRequest(Request):
     """Represents a request to set an ecoMAX parameter.
 
@@ -142,8 +139,6 @@ class SetEcomaxParameterRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_SET_ECOMAX_PARAMETER
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         try:
@@ -152,6 +147,7 @@ class SetEcomaxParameterRequest(Request):
             raise FrameDataError from e
 
 
+@frame_handler(FrameType.REQUEST_SET_MIXER_PARAMETER)
 class SetMixerParameterRequest(Request):
     """Represents a request to set a mixer parameter.
 
@@ -160,8 +156,6 @@ class SetMixerParameterRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_SET_MIXER_PARAMETER
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         try:
@@ -172,18 +166,30 @@ class SetMixerParameterRequest(Request):
             raise FrameDataError from e
 
 
+@frame_handler(FrameType.REQUEST_SET_SCHEDULE)
 class SetScheduleRequest(Request):
     """Represents a request to set a schedule."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_SET_SCHEDULE
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
-        return SchedulesStructure(self).encode(data)
+        message = b"\1"
+        try:
+            schedule_type = SCHEDULES.index(data[ATTR_TYPE])
+            message += schedule_type.to_bytes(length=1, byteorder="little")
+            message += int(data[ATTR_SWITCH]).to_bytes(length=1, byteorder="little")
+            message += int(data[ATTR_PARAMETER]).to_bytes(length=1, byteorder="little")
+            schedule = cast(list[list[bool]], data[ATTR_SCHEDULE])
+        except (KeyError, ValueError) as e:
+            raise FrameDataError from e
+
+        return bytearray(message) + bytearray(
+            join_bits(day[i : i + 8]) for day in schedule for i in range(0, len(day), 8)
+        )
 
 
+@frame_handler(FrameType.REQUEST_SET_THERMOSTAT_PARAMETER)
 class SetThermostatParameterRequest(Request):
     """Represents a request to set a thermostat parameter.
 
@@ -200,8 +206,6 @@ class SetThermostatParameterRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         try:
@@ -214,6 +218,7 @@ class SetThermostatParameterRequest(Request):
             raise FrameDataError from e
 
 
+@frame_handler(FrameType.REQUEST_START_MASTER)
 class StartMasterRequest(Request):
     """Represents a request to become a master.
 
@@ -223,9 +228,8 @@ class StartMasterRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_START_MASTER
-
 
+@frame_handler(FrameType.REQUEST_STOP_MASTER)
 class StopMasterRequest(Request):
     """Represents a request to stop being a master.
 
@@ -235,9 +239,8 @@ class StopMasterRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_STOP_MASTER
-
 
+@frame_handler(FrameType.REQUEST_THERMOSTAT_PARAMETERS)
 class ThermostatParametersRequest(Request):
     """Represents a thermostat parameters request.
 
@@ -247,20 +250,17 @@ class ThermostatParametersRequest(Request):
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_THERMOSTAT_PARAMETERS
-
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
         return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_START, 0)])
 
 
+@frame_handler(FrameType.REQUEST_UID)
 class UIDRequest(Request):
     """Represents an UID request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_UID
-
 
 __all__ = [
     "AlertsRequest",