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

pyplumio/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from pyplumio._version import __version__, __version_tuple__
+from pyplumio._version import __version__, __version_tuple__, version, version_tuple
 from pyplumio.connection import SerialConnection, TcpConnection
 from pyplumio.exceptions import (
     ChecksumError,
@@ -93,6 +93,8 @@ def open_tcp_connection(
 __all__ = [
     "__version__",
     "__version_tuple__",
+    "version",
+    "version_tuple",
     "AsyncProtocol",
     "ChecksumError",
     "ConnectionFailedError",

pyplumio/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.6.2'
+__version_tuple__ = version_tuple = (0, 6, 2)
 
 __commit_id__ = commit_id = None

pyplumio/connection.py

@@ -116,42 +116,6 @@ class Connection(ABC, TaskManager):
 
         yield await self.protocol.get(name, timeout=timeout)
 
-    @property
-    def get(self):  # type: ignore[no-untyped-def]
-        """Access the remote device.
-
-        Raise NotImplementedError when using protocol
-        different from AsyncProtocol.
-        """
-        if isinstance(self.protocol, AsyncProtocol):
-            return self.protocol.get
-
-        raise NotImplementedError
-
-    @property
-    def get_nowait(self):  # type: ignore[no-untyped-def]
-        """Access the remote device without waiting.
-
-        Raise NotImplementedError when using protocol
-        different from AsyncProtocol.
-        """
-        if isinstance(self.protocol, AsyncProtocol):
-            return self.protocol.get_nowait
-
-        raise NotImplementedError
-
-    @property
-    def wait_for(self):  # type: ignore[no-untyped-def]
-        """Wait for the remote device to become available.
-
-        Raise NotImplementedError when using protocol
-        different from AsyncProtocol.
-        """
-        if isinstance(self.protocol, AsyncProtocol):
-            return self.protocol.wait_for
-
-        raise NotImplementedError
-
     @property
     def protocol(self) -> Protocol:
         """Return the protocol object."""

pyplumio/const.py

@@ -8,7 +8,6 @@ from typing import Any, Final, Literal, TypeAlias
 # General attributes.
 ATTR_CONNECTED: Final = "connected"
 ATTR_COUNT: Final = "count"
-ATTR_CURRENT_TEMP: Final = "current_temp"
 ATTR_DEVICE_INDEX: Final = "device_index"
 ATTR_FRAME_ERRORS: Final = "frame_errors"
 ATTR_INDEX: Final = "index"
@@ -19,11 +18,7 @@ ATTR_SCHEDULE: Final = "schedule"
 ATTR_SETUP: Final = "setup"
 ATTR_SENSORS: Final = "sensors"
 ATTR_START: Final = "start"
-ATTR_STATE: Final = "state"
 ATTR_SWITCH: Final = "switch"
-ATTR_TARGET_TEMP: Final = "target_temp"
-ATTR_THERMOSTAT: Final = "thermostat"
-ATTR_TRANSMISSION: Final = "transmission"
 ATTR_TYPE: Final = "type"
 ATTR_VALUE: Final = "value"
 ATTR_SIZE: Final = "size"

pyplumio/data_types.py

@@ -8,7 +8,7 @@ import struct
 from typing import ClassVar, Final, Generic, TypeVar
 
 T = TypeVar("T")
-DataTypeT = TypeVar("DataTypeT", bound="DataType")
+_DataTypeT = TypeVar("_DataTypeT", bound="DataType")
 
 
 class DataType(ABC, Generic[T]):
@@ -66,7 +66,7 @@ class DataType(ABC, Generic[T]):
         return buffer if self.size == 0 else buffer[: self.size]
 
     @classmethod
-    def from_bytes(cls: type[DataTypeT], buffer: 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(buffer[offset:])

pyplumio/devices/__init__.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 from abc import ABC
 import asyncio
+from collections.abc import Callable
 from functools import cache
 import logging
-from typing import Any, ClassVar
+from typing import Any, ClassVar, TypeVar
 
 from pyplumio.const import ATTR_FRAME_ERRORS, DeviceType, FrameType, State
 from pyplumio.exceptions import RequestError, UnknownDeviceError
@@ -14,7 +15,7 @@ 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.parameters import NumericType, Parameter
+from pyplumio.parameters import Numeric, Parameter
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.utils import to_camelcase
 
@@ -63,7 +64,7 @@ class Device(ABC, EventManager):
     async def set(
         self,
         name: str,
-        value: NumericType | State | bool,
+        value: Numeric | State | bool,
         retries: int = 0,
         timeout: float | None = None,
     ) -> bool:
@@ -95,7 +96,7 @@ class Device(ABC, EventManager):
     def set_nowait(
         self,
         name: str,
-        value: NumericType | State | bool,
+        value: Numeric | State | bool,
         retries: int = 0,
         timeout: float | None = None,
     ) -> None:
@@ -232,10 +233,27 @@ class VirtualDevice(Device, ABC):
         self.index = index
 
 
+_PhysicalDeviceT = TypeVar("_PhysicalDeviceT", bound=PhysicalDevice)
+
+
+def device_handler(
+    device_type: DeviceType,
+) -> Callable[[type[_PhysicalDeviceT]], type[_PhysicalDeviceT]]:
+    """Specify device type (address) for the physical device class."""
+
+    def wrapper(cls: type[_PhysicalDeviceT]) -> type[_PhysicalDeviceT]:
+        """Wrap the physical device class."""
+        setattr(cls, "address", device_type)
+        return cls
+
+    return wrapper
+
+
 __all__ = [
     "Device",
     "PhysicalDevice",
     "VirtualDevice",
-    "is_known_device_type",
+    "device_hander",
     "get_device_handler",
+    "is_known_device_type",
 ]

pyplumio/devices/ecomax.py

@@ -6,7 +6,7 @@ import asyncio
 from collections.abc import Coroutine, Generator, Iterable
 import logging
 import time
-from typing import Any, Final
+from typing import Any, Final, NamedTuple
 
 from pyplumio.const import (
     ATTR_FRAME_ERRORS,
@@ -20,12 +20,12 @@ from pyplumio.const import (
     FrameType,
     State,
 )
-from pyplumio.devices import PhysicalDevice
+from pyplumio.devices import PhysicalDevice, device_handler
 from pyplumio.devices.mixer import Mixer
 from pyplumio.devices.thermostat import Thermostat
 from pyplumio.exceptions import RequestError
 from pyplumio.filters import on_change
-from pyplumio.frames import DataFrameDescription, Frame, Request
+from pyplumio.frames import Frame, Request
 from pyplumio.helpers.event_manager import event_listener
 from pyplumio.parameters import ParameterValues
 from pyplumio.parameters.ecomax import (
@@ -42,7 +42,6 @@ from pyplumio.structures.ecomax_parameters import (
     ATTR_ECOMAX_PARAMETERS,
 )
 from pyplumio.structures.mixer_parameters import ATTR_MIXER_PARAMETERS
-from pyplumio.structures.mixer_sensors import ATTR_MIXER_SENSORS
 from pyplumio.structures.network_info import ATTR_NETWORK, NetworkInfo
 from pyplumio.structures.product_info import ATTR_PRODUCT, ProductInfo
 from pyplumio.structures.regulator_data_schema import ATTR_REGDATA_SCHEMA
@@ -56,8 +55,8 @@ from pyplumio.structures.schedules import (
     ScheduleSwitch,
     ScheduleSwitchDescription,
 )
+from pyplumio.structures.sensor_data import ATTR_MIXER_SENSORS, ATTR_THERMOSTAT_SENSORS
 from pyplumio.structures.thermostat_parameters import ATTR_THERMOSTAT_PARAMETERS
-from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTAT_SENSORS
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -102,46 +101,30 @@ class FuelMeter:
         return None
 
 
-REQUIRED: tuple[DataFrameDescription, ...] = (
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_UID,
-        provides=ATTR_PRODUCT,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_REGULATOR_DATA_SCHEMA,
-        provides=ATTR_REGDATA_SCHEMA,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_ECOMAX_PARAMETERS,
-        provides=ATTR_ECOMAX_PARAMETERS,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_ALERTS,
-        provides=ATTR_TOTAL_ALERTS,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_SCHEDULES,
-        provides=ATTR_SCHEDULES,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_MIXER_PARAMETERS,
-        provides=ATTR_MIXER_PARAMETERS,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_THERMOSTAT_PARAMETERS,
-        provides=ATTR_THERMOSTAT_PARAMETERS,
-    ),
-    DataFrameDescription(
-        frame_type=FrameType.REQUEST_PASSWORD,
-        provides=ATTR_PASSWORD,
-    ),
+class DataKey(NamedTuple):
+    """Map a data key to frame type."""
+
+    key: str
+    provided_by: FrameType
+
+
+REQUIRED_KEYS: tuple[DataKey, ...] = (
+    DataKey(ATTR_PRODUCT, FrameType.REQUEST_UID),
+    DataKey(ATTR_REGDATA_SCHEMA, FrameType.REQUEST_REGULATOR_DATA_SCHEMA),
+    DataKey(ATTR_ECOMAX_PARAMETERS, FrameType.REQUEST_ECOMAX_PARAMETERS),
+    DataKey(ATTR_TOTAL_ALERTS, FrameType.REQUEST_ALERTS),
+    DataKey(ATTR_SCHEDULES, FrameType.REQUEST_SCHEDULES),
+    DataKey(ATTR_MIXER_PARAMETERS, FrameType.REQUEST_MIXER_PARAMETERS),
+    DataKey(ATTR_THERMOSTAT_PARAMETERS, FrameType.REQUEST_THERMOSTAT_PARAMETERS),
+    DataKey(ATTR_PASSWORD, FrameType.REQUEST_PASSWORD),
 )
 
-REQUIRED_TYPES = [description.frame_type for description in REQUIRED]
+REQUIRED_TYPES = [frame_type for _, frame_type in REQUIRED_KEYS]
 
 SETUP_TIMEOUT: Final = 60.0
 
 
+@device_handler(DeviceType.ECOMAX)
 class EcoMAX(PhysicalDevice):
     """Represents an ecoMAX controller."""
 
@@ -149,8 +132,6 @@ class EcoMAX(PhysicalDevice):
 
     _fuel_meter: FuelMeter
 
-    address = DeviceType.ECOMAX
-
     def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
         """Initialize a new ecoMAX controller."""
         super().__init__(queue, network)
@@ -165,26 +146,26 @@ class EcoMAX(PhysicalDevice):
 
         super().handle_frame(frame)
 
-    def _mixers(self, indexes: Iterable[int]) -> Generator[Mixer, None, None]:
+    def _mixers(self, indexes: Iterable[int]) -> Generator[Mixer]:
         """Iterate through the mixer indexes.
 
         For each index, return or create an instance of the mixer class.
         Once done, dispatch the 'mixers' event without waiting.
         """
-        mixers: dict[int, Mixer] = self.data.setdefault(ATTR_MIXERS, {})
+        mixers: dict[int, Mixer] = self._data.setdefault(ATTR_MIXERS, {})
         for index in indexes:
             yield mixers.setdefault(index, Mixer(self.queue, parent=self, index=index))
 
         return self.dispatch_nowait(ATTR_MIXERS, mixers)
 
-    def _thermostats(self, indexes: Iterable[int]) -> Generator[Thermostat, None, None]:
+    def _thermostats(self, indexes: Iterable[int]) -> Generator[Thermostat]:
         """Iterate through the thermostat indexes.
 
         For each index, return or create an instance of the thermostat
         class. Once done, dispatch the 'thermostats' event without
         waiting.
         """
-        thermostats: dict[int, Thermostat] = self.data.setdefault(ATTR_THERMOSTATS, {})
+        thermostats: dict[int, Thermostat] = self._data.setdefault(ATTR_THERMOSTATS, {})
         for index in indexes:
             yield thermostats.setdefault(
                 index, Thermostat(self.queue, parent=self, index=index)
@@ -203,9 +184,8 @@ class EcoMAX(PhysicalDevice):
     async def _set_ecomax_state(self, state: State) -> bool:
         """Try to set the ecoMAX control state."""
         try:
-            switch: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
-            return await switch.set(state)
-        except KeyError:
+            return await self.set(ATTR_ECOMAX_CONTROL, state, timeout=0.0)
+        except asyncio.TimeoutError:
             _LOGGER.error("ecoMAX control is not available. Please try again later.")
 
         return False
@@ -249,10 +229,7 @@ class EcoMAX(PhysicalDevice):
             return False
 
         results = await asyncio.gather(
-            *(
-                self.request(description.provides, description.frame_type)
-                for description in REQUIRED
-            ),
+            *(self.request(key, frame_type) for key, frame_type in REQUIRED_KEYS),
             return_exceptions=True,
         )
 
@@ -352,7 +329,7 @@ class EcoMAX(PhysicalDevice):
     ) -> bool:
         """Update schedule parameters and dispatch the events."""
 
-        def _schedule_parameter_events() -> Generator[Coroutine, Any, None]:
+        def _schedule_parameter_events() -> Generator[Coroutine]:
             """Get dispatch calls for schedule parameter events."""
             for index, values in parameters:
                 description = SCHEDULE_PARAMETERS[index]

pyplumio/devices/ecoster.py

@@ -3,15 +3,14 @@
 from __future__ import annotations
 
 from pyplumio.const import DeviceType
-from pyplumio.devices import PhysicalDevice
+from pyplumio.devices import PhysicalDevice, device_handler
 
 
+@device_handler(DeviceType.ECOSTER)
 class EcoSTER(PhysicalDevice):
     """Represents an ecoSTER thermostat."""
 
     __slots__ = ()
 
-    address = DeviceType.ECOSTER
-
 
 __all__ = ["EcoSTER"]