PyPlumIO 0.5.42__py3-none-any.whl → 0.5.44__py3-none-any.whl

pyplumio/__init__.py

@@ -13,6 +13,7 @@ from pyplumio.exceptions import (
     ProtocolError,
     PyPlumIOError,
     ReadError,
+    RequestError,
     UnknownDeviceError,
     UnknownFrameError,
 )
@@ -90,6 +91,8 @@ def open_tcp_connection(
 
 
 __all__ = [
+    "__version__",
+    "__version_tuple__",
     "AsyncProtocol",
     "ChecksumError",
     "ConnectionFailedError",
@@ -107,8 +110,6 @@ __all__ = [
     "UnknownDeviceError",
     "UnknownFrameError",
     "WirelessParameters",
-    "__version__",
-    "__version_tuple__",
     "open_serial_connection",
     "open_tcp_connection",
 ]

pyplumio/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.42'
-__version_tuple__ = version_tuple = (0, 5, 42)
+__version__ = version = '0.5.44'
+__version_tuple__ = version_tuple = (0, 5, 44)

pyplumio/connection.py

@@ -5,9 +5,9 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import asyncio
 import logging
-from typing import Any, Final, cast
+from typing import Any, Final
 
-from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE, SerialException
+from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE
 
 from pyplumio.exceptions import ConnectionFailedError
 from pyplumio.helpers.task_manager import TaskManager
@@ -24,7 +24,7 @@ try:
 
     _LOGGER.info("Using pyserial-asyncio-fast in place of pyserial-asyncio")
 except ImportError:
-    import serial_asyncio as pyserial_asyncio
+    import serial_asyncio as pyserial_asyncio  # type: ignore[no-redef]
 
 
 class Connection(ABC, TaskManager):
@@ -73,7 +73,7 @@ class Connection(ABC, TaskManager):
         try:
             reader, writer = await self._open_connection()
             self.protocol.connection_established(reader, writer)
-        except (OSError, SerialException, asyncio.TimeoutError) as err:
+        except (OSError, asyncio.TimeoutError) as err:
             raise ConnectionFailedError from err
 
     async def _reconnect(self) -> None:
@@ -184,14 +184,14 @@ class SerialConnection(Connection):
         self,
     ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
         """Open the connection and return reader and writer objects."""
-        return cast(
-            tuple[asyncio.StreamReader, asyncio.StreamWriter],
-            await pyserial_asyncio.open_serial_connection(
-                url=self.device,
-                baudrate=self.baudrate,
-                bytesize=EIGHTBITS,
-                parity=PARITY_NONE,
-                stopbits=STOPBITS_ONE,
-                **self._kwargs,
-            ),
+        return await pyserial_asyncio.open_serial_connection(
+            url=self.device,
+            baudrate=self.baudrate,
+            bytesize=EIGHTBITS,
+            parity=PARITY_NONE,
+            stopbits=STOPBITS_ONE,
+            **self._kwargs,
         )
+
+
+__all__ = ["Connection", "TcpConnection", "SerialConnection"]

pyplumio/const.py

@@ -14,11 +14,11 @@ ATTR_CURRENT_TEMP: Final = "current_temp"
 ATTR_DEVICE_INDEX: Final = "device_index"
 ATTR_FRAME_ERRORS: Final = "frame_errors"
 ATTR_INDEX: Final = "index"
-ATTR_LOADED: Final = "loaded"
 ATTR_OFFSET: Final = "offset"
 ATTR_PARAMETER: Final = "parameter"
 ATTR_PASSWORD: Final = "password"
 ATTR_SCHEDULE: Final = "schedule"
+ATTR_SETUP: Final = "setup"
 ATTR_SENSORS: Final = "sensors"
 ATTR_START: Final = "start"
 ATTR_STATE: Final = "state"
@@ -91,6 +91,13 @@ 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."""
@@ -222,6 +229,4 @@ PERCENTAGE: Final = "%"
 
 STATE_ON: Final = "on"
 STATE_OFF: Final = "off"
-
-
 State: TypeAlias = Literal["on", "off"]

pyplumio/{helpers/data_types.py → data_types.py}

@@ -54,15 +54,15 @@ class DataType(ABC, Generic[T]):
 
         return NotImplemented
 
-    def _slice_data(self, data: bytes) -> bytes:
+    def _slice_to_size(self, buffer: bytes) -> bytes:
         """Slice the data to data type size."""
-        return data if self.size == 0 else data[: self.size]
+        return buffer if self.size == 0 else buffer[: self.size]
 
     @classmethod
-    def from_bytes(cls: type[DataTypeT], data: bytes, offset: int = 0) -> DataTypeT:
+    def from_bytes(cls: type[DataTypeT], buffer: bytes, offset: int = 0) -> DataTypeT:
         """Initialize a new data type from bytes."""
         data_type = cls()
-        data_type.unpack(data[offset:])
+        data_type.unpack(buffer[offset:])
         return data_type
 
     def to_bytes(self) -> bytes:
@@ -84,7 +84,7 @@ class DataType(ABC, Generic[T]):
         """Pack the data."""
 
     @abstractmethod
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
 
 
@@ -138,9 +138,9 @@ class BitArray(DataType[int]):
 
         return b""
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._value = UnsignedChar.from_bytes(data[:1]).value
+        self._value = UnsignedChar.from_bytes(buffer[:1]).value
 
     @property
     def value(self) -> bool:
@@ -170,9 +170,9 @@ class IPv4(DataType[str]):
         """Pack the data."""
         return socket.inet_aton(self.value)
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._value = socket.inet_ntoa(self._slice_data(data))
+        self._value = socket.inet_ntoa(self._slice_to_size(buffer))
 
 
 class IPv6(DataType[str]):
@@ -189,9 +189,9 @@ class IPv6(DataType[str]):
         """Pack the data."""
         return socket.inet_pton(socket.AF_INET6, self.value)
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._value = socket.inet_ntop(socket.AF_INET6, self._slice_data(data))
+        self._value = socket.inet_ntop(socket.AF_INET6, self._slice_to_size(buffer))
 
 
 class String(DataType[str]):
@@ -208,9 +208,9 @@ class String(DataType[str]):
         """Pack the data."""
         return self.value.encode() + b"\0"
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._value = data.split(b"\0", 1)[0].decode("utf-8", "replace")
+        self._value = buffer.split(b"\0", 1)[0].decode("utf-8", "replace")
         self._size = len(self.value) + 1
 
 
@@ -228,10 +228,10 @@ class VarBytes(DataType[bytes]):
         """Pack the data."""
         return UnsignedChar(self.size - 1).to_bytes() + self.value
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._size = data[0] + 1
-        self._value = data[1 : self.size]
+        self._size = buffer[0] + 1
+        self._value = buffer[1 : self.size]
 
 
 class VarString(DataType[str]):
@@ -248,10 +248,10 @@ class VarString(DataType[str]):
         """Pack the data."""
         return UnsignedChar(self.size - 1).to_bytes() + self.value.encode()
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._size = data[0] + 1
-        self._value = data[1 : self.size].decode("utf-8", "replace")
+        self._size = buffer[0] + 1
+        self._value = buffer[1 : self.size].decode("utf-8", "replace")
 
 
 class BuiltInDataType(DataType[T], ABC):
@@ -265,9 +265,9 @@ class BuiltInDataType(DataType[T], ABC):
         """Pack the data."""
         return self._struct.pack(self.value)
 
-    def unpack(self, data: bytes) -> None:
+    def unpack(self, buffer: bytes) -> None:
         """Unpack the data."""
-        self._value = self._struct.unpack_from(data)[0]
+        self._value = self._struct.unpack_from(buffer)[0]
 
     @property
     def size(self) -> int:
@@ -379,3 +379,5 @@ DATA_TYPES: tuple[type[DataType], ...] = (
     IPv4,
     IPv6,
 )
+
+__all__ = ["DataType"] + list({dt.__name__ for dt in DATA_TYPES})

pyplumio/devices/__init__.py

@@ -8,13 +8,13 @@ from functools import cache
 import logging
 from typing import Any, ClassVar
 
-from pyplumio.const import ATTR_FRAME_ERRORS, ATTR_LOADED, DeviceType, FrameType
+from pyplumio.const import ATTR_FRAME_ERRORS, DeviceType, FrameType, State
 from pyplumio.exceptions import RequestError, UnknownDeviceError
-from pyplumio.frames import DataFrameDescription, Frame, Request, is_known_frame_type
-from pyplumio.helpers.event_manager import EventManager
+from pyplumio.filters import on_change
+from pyplumio.frames import Frame, Request, is_known_frame_type
+from pyplumio.helpers.event_manager import EventManager, event_listener
 from pyplumio.helpers.factory import create_instance
-from pyplumio.helpers.parameter import NumericType, Parameter, State
-from pyplumio.structures.frame_versions import ATTR_FRAME_VERSIONS
+from pyplumio.parameters import NumericType, Parameter
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.utils import to_camelcase
 
@@ -47,6 +47,8 @@ def get_device_handler(device_type: int) -> str:
 class Device(ABC, EventManager):
     """Represents a device."""
 
+    __slots__ = ("queue",)
+
     queue: asyncio.Queue[Frame]
 
     def __init__(self, queue: asyncio.Queue[Frame]) -> None:
@@ -123,9 +125,11 @@ class PhysicalDevice(Device, ABC):
     virtual devices associated with them via parent property.
     """
 
+    __slots__ = ("address", "_network", "_frame_versions")
+
     address: ClassVar[int]
+
     _network: NetworkInfo
-    _setup_frames: tuple[DataFrameDescription, ...]
     _frame_versions: dict[int, int]
 
     def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
@@ -134,22 +138,26 @@ class PhysicalDevice(Device, ABC):
         self._network = network
         self._frame_versions = {}
 
-        async def update_frame_versions(versions: dict[int, int]) -> None:
-            """Check frame versions and update outdated frames."""
-            for frame_type, version in versions.items():
-                if (
-                    is_known_frame_type(frame_type)
-                    and self.supports_frame_type(frame_type)
-                    and not self.has_frame_version(frame_type, version)
-                ):
-                    _LOGGER.debug(
-                        "Updating frame %s to version %i", frame_type, version
-                    )
-                    request = await Request.create(frame_type, recipient=self.address)
-                    self.queue.put_nowait(request)
-                    self._frame_versions[frame_type] = version
-
-        self.subscribe(ATTR_FRAME_VERSIONS, update_frame_versions)
+    @event_listener(filter=on_change)
+    async def on_event_frame_versions(self, versions: dict[int, int]) -> None:
+        """Check frame versions and update outdated frames."""
+        _LOGGER.info("Received version table")
+        for frame_type, version in versions.items():
+            if (
+                is_known_frame_type(frame_type)
+                and self.supports_frame_type(frame_type)
+                and not self.has_frame_version(frame_type, version)
+            ):
+                await self._request_frame_version(frame_type, version)
+                self._frame_versions[frame_type] = version
+
+    async def _request_frame_version(
+        self, frame_type: FrameType | int, version: int
+    ) -> None:
+        """Request frame version from the device."""
+        _LOGGER.info("Updating frame %s to version %i", repr(frame_type), version)
+        request = await Request.create(frame_type, recipient=self.address)
+        self.queue.put_nowait(request)
 
     def has_frame_version(self, frame_type: FrameType | int, version: int) -> bool:
         """Return True if frame data is up to date, False otherwise."""
@@ -169,25 +177,6 @@ class PhysicalDevice(Device, ABC):
             for name, value in frame.data.items():
                 self.dispatch_nowait(name, value)
 
-    async def async_setup(self) -> bool:
-        """Set up addressable device."""
-        results = await asyncio.gather(
-            *(
-                self.request(description.provides, description.frame_type)
-                for description in self._setup_frames
-            ),
-            return_exceptions=True,
-        )
-
-        errors = [
-            result.frame_type for result in results if isinstance(result, RequestError)
-        ]
-
-        await asyncio.gather(
-            self.dispatch(ATTR_FRAME_ERRORS, errors), self.dispatch(ATTR_LOADED, True)
-        )
-        return True
-
     async def request(
         self, name: str, frame_type: FrameType, retries: int = 3, timeout: float = 3.0
     ) -> Any:
@@ -195,6 +184,7 @@ class PhysicalDevice(Device, ABC):
 
         If value is not available before timeout, retry request.
         """
+        _LOGGER.info("Requesting '%s' with %s", name, repr(frame_type))
         request = await Request.create(frame_type, recipient=self.address)
         while retries > 0:
             try:
@@ -218,6 +208,8 @@ class PhysicalDevice(Device, ABC):
 class VirtualDevice(Device, ABC):
     """Represents a virtual device associated with physical device."""
 
+    __slots__ = ("parent", "index")
+
     parent: PhysicalDevice
     index: int
 
@@ -228,3 +220,12 @@ class VirtualDevice(Device, ABC):
         super().__init__(queue)
         self.parent = parent
         self.index = index
+
+
+__all__ = [
+    "Device",
+    "PhysicalDevice",
+    "VirtualDevice",
+    "is_known_device_type",
+    "get_device_handler",
+]