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

pyplumio/frames/requests.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, ClassVar
+from typing import Any
 
 from pyplumio.const import (
     ATTR_COUNT,
@@ -25,7 +25,7 @@ class ProgramVersionRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_PROGRAM_VERSION
+    frame_type = FrameType.REQUEST_PROGRAM_VERSION
 
     def response(self, **kwargs: Any) -> Response | None:
         """Return a response frame."""
@@ -37,7 +37,7 @@ class CheckDeviceRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_CHECK_DEVICE
+    frame_type = FrameType.REQUEST_CHECK_DEVICE
 
     def response(self, **kwargs: Any) -> Response | None:
         """Return a response frame."""
@@ -49,7 +49,7 @@ class UIDRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_UID
+    frame_type = FrameType.REQUEST_UID
 
 
 class PasswordRequest(Request):
@@ -57,7 +57,7 @@ class PasswordRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_PASSWORD
+    frame_type = FrameType.REQUEST_PASSWORD
 
 
 class EcomaxParametersRequest(Request):
@@ -68,7 +68,7 @@ class EcomaxParametersRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_ECOMAX_PARAMETERS
+    frame_type = FrameType.REQUEST_ECOMAX_PARAMETERS
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -84,7 +84,7 @@ class MixerParametersRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_MIXER_PARAMETERS
+    frame_type = FrameType.REQUEST_MIXER_PARAMETERS
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -100,7 +100,7 @@ class ThermostatParametersRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_THERMOSTAT_PARAMETERS
+    frame_type = FrameType.REQUEST_THERMOSTAT_PARAMETERS
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -112,7 +112,7 @@ class RegulatorDataSchemaRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_REGULATOR_DATA_SCHEMA
+    frame_type = FrameType.REQUEST_REGULATOR_DATA_SCHEMA
 
 
 class SetEcomaxParameterRequest(Request):
@@ -123,7 +123,7 @@ class SetEcomaxParameterRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_SET_ECOMAX_PARAMETER
+    frame_type = FrameType.REQUEST_SET_ECOMAX_PARAMETER
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -141,7 +141,7 @@ class SetMixerParameterRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_SET_MIXER_PARAMETER
+    frame_type = FrameType.REQUEST_SET_MIXER_PARAMETER
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -169,7 +169,7 @@ class SetThermostatParameterRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
+    frame_type = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -192,7 +192,7 @@ class EcomaxControlRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_ECOMAX_CONTROL
+    frame_type = FrameType.REQUEST_ECOMAX_CONTROL
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -211,7 +211,7 @@ class StartMasterRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_START_MASTER
+    frame_type = FrameType.REQUEST_START_MASTER
 
 
 class StopMasterRequest(Request):
@@ -223,7 +223,7 @@ class StopMasterRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_STOP_MASTER
+    frame_type = FrameType.REQUEST_STOP_MASTER
 
 
 class AlertsRequest(Request):
@@ -235,7 +235,7 @@ class AlertsRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_ALERTS
+    frame_type = FrameType.REQUEST_ALERTS
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -247,7 +247,7 @@ class SchedulesRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_SCHEDULES
+    frame_type = FrameType.REQUEST_SCHEDULES
 
 
 class SetScheduleRequest(Request):
@@ -255,7 +255,7 @@ class SetScheduleRequest(Request):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_SET_SCHEDULE
+    frame_type = FrameType.REQUEST_SET_SCHEDULE
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""

pyplumio/frames/responses.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, ClassVar
+from typing import Any
 
 from pyplumio.const import ATTR_PASSWORD, FrameType
 from pyplumio.frames import Response
@@ -25,7 +25,7 @@ class ProgramVersionResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_PROGRAM_VERSION
+    frame_type = FrameType.RESPONSE_PROGRAM_VERSION
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -44,7 +44,7 @@ class DeviceAvailableResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_DEVICE_AVAILABLE
+    frame_type = FrameType.RESPONSE_DEVICE_AVAILABLE
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -63,7 +63,7 @@ class UIDResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_UID
+    frame_type = FrameType.RESPONSE_UID
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
@@ -82,7 +82,7 @@ class PasswordResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_PASSWORD
+    frame_type = FrameType.RESPONSE_PASSWORD
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
@@ -98,7 +98,7 @@ class EcomaxParametersResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_ECOMAX_PARAMETERS
+    frame_type = FrameType.RESPONSE_ECOMAX_PARAMETERS
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
@@ -113,7 +113,7 @@ class MixerParametersResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_MIXER_PARAMETERS
+    frame_type = FrameType.RESPONSE_MIXER_PARAMETERS
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
@@ -128,7 +128,7 @@ class ThermostatParametersResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_THERMOSTAT_PARAMETERS
+    frame_type = FrameType.RESPONSE_THERMOSTAT_PARAMETERS
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
@@ -144,7 +144,7 @@ class RegulatorDataSchemaResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_REGULATOR_DATA_SCHEMA
+    frame_type = FrameType.RESPONSE_REGULATOR_DATA_SCHEMA
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
@@ -160,7 +160,7 @@ class SetEcomaxParameterResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_SET_ECOMAX_PARAMETER
+    frame_type = FrameType.RESPONSE_SET_ECOMAX_PARAMETER
 
 
 class SetMixerParameterResponse(Response):
@@ -172,7 +172,7 @@ class SetMixerParameterResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_SET_MIXER_PARAMETER
+    frame_type = FrameType.RESPONSE_SET_MIXER_PARAMETER
 
 
 class SetThermostatParameterResponse(Response):
@@ -184,7 +184,7 @@ class SetThermostatParameterResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_SET_THERMOSTAT_PARAMETER
+    frame_type = FrameType.RESPONSE_SET_THERMOSTAT_PARAMETER
 
 
 class EcomaxControlResponse(Response):
@@ -196,7 +196,7 @@ class EcomaxControlResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_ECOMAX_CONTROL
+    frame_type = FrameType.RESPONSE_ECOMAX_CONTROL
 
 
 class AlertsResponse(Response):
@@ -204,7 +204,7 @@ class AlertsResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_ALERTS
+    frame_type = FrameType.RESPONSE_ALERTS
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
@@ -216,7 +216,7 @@ class SchedulesResponse(Response):
 
     __slots__ = ()
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_SCHEDULES
+    frame_type = FrameType.RESPONSE_SCHEDULES
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""

pyplumio/helpers/data_types.py

@@ -5,36 +5,58 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import socket
 import struct
-from typing import Any, ClassVar, Final, TypeVar
+from typing import ClassVar, Final, Generic, TypeVar
 
+T = TypeVar("T")
+DataTypeT = TypeVar("DataTypeT", bound="DataType")
 
-class DataType(ABC):
-    """Represents a base data type."""
+
+class DataType(ABC, Generic[T]):
+    """Represents a data type."""
 
     __slots__ = ("_value", "_size")
 
-    _value: Any
+    _value: T
     _size: int
 
-    def __init__(self, value: Any = None):
+    def __init__(self, value: T | None = None):
         """Initialize a new data type."""
-        self._value = value
+        if value is not None:
+            self._value = value
+
         self._size = 0
 
     def __repr__(self) -> str:
         """Return serializable string representation of the class."""
-        return f"{self.__class__.__name__}(value={self._value})"
+        if hasattr(self, "_value"):
+            return f"{self.__class__.__name__}(value={self._value})"
+
+        return f"{self.__class__.__name__}()"
 
     def __eq__(self, other: object) -> bool:
         """Compare if this data type is equal to other."""
-        if isinstance(other, DataType):
+        if (
+            isinstance(other, DataType)
+            and hasattr(other, "_value")
+            and hasattr(self, "_value")
+        ):
             return bool(self._value == other._value)
 
-        return bool(self._value == other)
+        if (
+            isinstance(other, DataType)
+            and not hasattr(other, "_value")
+            and not hasattr(self, "_value")
+        ):
+            return type(self) is type(other)
+
+        if hasattr(self, "_value"):
+            return bool(self._value == other)
+
+        return NotImplemented
 
     def _slice_data(self, data: bytes) -> bytes:
         """Slice the data to data type size."""
-        return data[: self.size] if self.size is not None else data
+        return data if self.size == 0 else data[: self.size]
 
     @classmethod
     def from_bytes(cls: type[DataTypeT], data: bytes, offset: int = 0) -> DataTypeT:
@@ -48,7 +70,7 @@ class DataType(ABC):
         return self.pack()
 
     @property
-    def value(self) -> Any:
+    def value(self) -> T:
         """Return the data type value."""
         return self._value
 
@@ -66,9 +88,6 @@ class DataType(ABC):
         """Unpack the data."""
 
 
-DataTypeT = TypeVar("DataTypeT", bound=DataType)
-
-
 class Undefined(DataType):
     """Represents an undefined."""
 
@@ -86,21 +105,26 @@ class Undefined(DataType):
 BITARRAY_LAST_INDEX: Final = 7
 
 
-class BitArray(DataType):
+class BitArray(DataType[int]):
     """Represents a bit array."""
 
     __slots__ = ("_index",)
 
     _index: int
 
-    def __init__(self, value: Any = None, index: int = 0):
+    def __init__(self, value: bool | None = None, index: int = 0):
         """Initialize a new bit array."""
         super().__init__(value)
         self._index = index
 
     def __repr__(self) -> str:
         """Return serializable string representation of the class."""
-        return f"{self.__class__.__name__}(value={self._value}, index={self._index})"
+        if hasattr(self, "_value"):
+            return (
+                f"{self.__class__.__name__}(value={self._value}, index={self._index})"
+            )
+
+        return f"{self.__class__.__name__}(index={self._index})"
 
     def next(self, index: int = 0) -> int:
         """Set current bit and return the next index in the bit array."""
@@ -109,16 +133,22 @@ class BitArray(DataType):
 
     def pack(self) -> bytes:
         """Pack the data."""
-        return UnsignedChar(self._value).to_bytes()
+        if hasattr(self, "_value"):
+            return UnsignedChar(self._value).to_bytes()
+
+        return b""
 
     def unpack(self, data: bytes) -> None:
         """Unpack the data."""
         self._value = UnsignedChar.from_bytes(data[:1]).value
 
     @property
-    def value(self) -> bool | None:
+    def value(self) -> bool:
         """Return the data type value."""
-        return None if self._value is None else bool(self._value & (1 << self._index))
+        if hasattr(self, "_value"):
+            return bool(self._value & (1 << self._index))
+
+        raise ValueError
 
     @property
     def size(self) -> int:
@@ -126,7 +156,7 @@ class BitArray(DataType):
         return 1 if self._index == BITARRAY_LAST_INDEX else 0
 
 
-class IPv4(DataType):
+class IPv4(DataType[str]):
     """Represents an IPv4 address."""
 
     __slots__ = ()
@@ -145,7 +175,7 @@ class IPv4(DataType):
         self._value = socket.inet_ntoa(self._slice_data(data))
 
 
-class IPv6(DataType):
+class IPv6(DataType[str]):
     """Represents an IPv6 address."""
 
     __slots__ = ()
@@ -164,20 +194,19 @@ class IPv6(DataType):
         self._value = socket.inet_ntop(socket.AF_INET6, self._slice_data(data))
 
 
-class String(DataType):
-    """Represents a null terminated string."""
+class String(DataType[str]):
+    """Represents a null-terminated string."""
 
     __slots__ = ()
 
-    def __init__(self, value: Any = ""):
-        """Initialize a new null terminated string data type."""
+    def __init__(self, value: str = ""):
+        """Initialize a new null-terminated string data type."""
         super().__init__(value)
         self._size = len(self.value) + 1
 
     def pack(self) -> bytes:
         """Pack the data."""
-        value: str = self.value
-        return value.encode() + b"\0"
+        return self.value.encode() + b"\0"
 
     def unpack(self, data: bytes) -> None:
         """Unpack the data."""
@@ -185,20 +214,19 @@ class String(DataType):
         self._size = len(self.value) + 1
 
 
-class VarBytes(DataType):
-    """Represents a variable length bytes."""
+class VarBytes(DataType[bytes]):
+    """Represents a variable-length bytes."""
 
     __slots__ = ()
 
-    def __init__(self, value: Any = b""):
-        """Initialize a new variable length bytes data type."""
+    def __init__(self, value: bytes = b""):
+        """Initialize a new variable-length bytes data type."""
         super().__init__(value)
         self._size = len(value) + 1
 
     def pack(self) -> bytes:
         """Pack the data."""
-        value: bytes = self.value
-        return UnsignedChar(self.size - 1).to_bytes() + value
+        return UnsignedChar(self.size - 1).to_bytes() + self.value
 
     def unpack(self, data: bytes) -> None:
         """Unpack the data."""
@@ -206,26 +234,30 @@ class VarBytes(DataType):
         self._value = data[1 : self.size]
 
 
-class VarString(VarBytes):
+class VarString(DataType[str]):
     """Represents a variable length string."""
 
     __slots__ = ()
 
+    def __init__(self, value: str = ""):
+        """Initialize a new variable length bytes data type."""
+        super().__init__(value)
+        self._size = len(value) + 1
+
     def pack(self) -> bytes:
         """Pack the data."""
-        value: str = self.value
-        return UnsignedChar(self.size - 1).to_bytes() + value.encode()
+        return UnsignedChar(self.size - 1).to_bytes() + self.value.encode()
 
     def unpack(self, data: bytes) -> None:
         """Unpack the data."""
-        super().unpack(data)
-        self._value = self.value.decode()
+        self._size = data[0] + 1
+        self._value = data[1 : self.size].decode("utf-8", "replace")
 
 
-class BuiltInDataType(DataType, ABC):
+class BuiltInDataType(DataType[T], ABC):
     """Represents a data type that is supported by the struct module."""
 
-    __slots__ = ()
+    __slots__ = ("_struct",)
 
     _struct: ClassVar[struct.Struct]
 
@@ -240,86 +272,90 @@ class BuiltInDataType(DataType, ABC):
     @property
     def size(self) -> int:
         """Return a data type size."""
-        return self._struct.size
+        if not self._size:
+            self._size = self._struct.size
 
+        return self._size
 
-class SignedChar(BuiltInDataType):
+
+class SignedChar(BuiltInDataType[int]):
     """Represents a signed char."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<b")
+    _struct = struct.Struct("<b")
 
 
-class UnsignedChar(BuiltInDataType):
+class UnsignedChar(BuiltInDataType[int]):
     """Represents an unsigned char."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<B")
+    _struct = struct.Struct("<B")
 
 
-class Short(BuiltInDataType):
-    """Represents a 16 bit integer."""
+class Short(BuiltInDataType[int]):
+    """Represents a 16-bit integer."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<h")
+    _struct = struct.Struct("<h")
 
 
-class UnsignedShort(BuiltInDataType):
-    """Represents an unsigned 16 bit integer."""
+class UnsignedShort(BuiltInDataType[int]):
+    """Represents an unsigned 16-bit integer."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<H")
+    _struct = struct.Struct("<H")
 
 
-class Int(BuiltInDataType):
-    """Represents a 32 bit integer."""
+class Int(BuiltInDataType[int]):
+    """Represents a 32-bit integer."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<i")
+    _struct = struct.Struct("<i")
 
 
-class UnsignedInt(BuiltInDataType):
-    """Represents a unsigned 32 bit integer."""
+class UnsignedInt(BuiltInDataType[int]):
+    """Represents a unsigned 32-bit integer."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<I")
+    _struct = struct.Struct("<I")
 
 
-class Float(BuiltInDataType):
+class Float(BuiltInDataType[int]):
     """Represents a float."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<f")
+    _struct = struct.Struct("<f")
 
 
-class Double(BuiltInDataType):
+class Double(BuiltInDataType[int]):
     """Represents a double."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<d")
+    _struct = struct.Struct("<d")
 
 
-class Int64(BuiltInDataType):
-    """Represents a 64 bit signed integer."""
+class Int64(BuiltInDataType[int]):
+    """Represents a 64-bit signed integer."""
 
     __slots__ = ()
 
-    _struct: ClassVar[struct.Struct] = struct.Struct("<q")
+    _struct = struct.Struct("<q")
 
 
-class UInt64(BuiltInDataType):
-    """Represents a 64 bit unsigned integer."""
+class UInt64(BuiltInDataType[int]):
+    """Represents a 64-bit unsigned integer."""
 
     __slots__ = ()
-    _struct: ClassVar[struct.Struct] = struct.Struct("<Q")
+
+    _struct = struct.Struct("<Q")
 
 
 # The regdata type map links data type classes to their