PyPlumIO 0.5.21__py3-none-any.whl → 0.5.23__py3-none-any.whl

pyplumio/devices/thermostat.py

@@ -3,43 +3,47 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Sequence
-from typing import Any
+from collections.abc import Coroutine, Generator, Sequence
+from typing import TYPE_CHECKING, Any
 
 from pyplumio.devices import AddressableDevice, SubDevice
 from pyplumio.helpers.parameter import ParameterValues
 from pyplumio.structures.thermostat_parameters import (
     ATTR_THERMOSTAT_PARAMETERS,
     THERMOSTAT_PARAMETERS,
-    ThermostatBinaryParameter,
-    ThermostatBinaryParameterDescription,
-    ThermostatParameter,
+    ThermostatNumber,
+    ThermostatSwitch,
+    ThermostatSwitchDescription,
 )
 from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTAT_SENSORS
 
+if TYPE_CHECKING:
+    from pyplumio.frames import Frame
+
 
 class Thermostat(SubDevice):
     """Represents a thermostat."""
 
-    def __init__(self, queue: asyncio.Queue, parent: AddressableDevice, index: int = 0):
+    def __init__(
+        self, queue: asyncio.Queue[Frame], parent: AddressableDevice, index: int = 0
+    ):
         """Initialize a new thermostat."""
         super().__init__(queue, parent, index)
-        self.subscribe(ATTR_THERMOSTAT_SENSORS, self._handle_sensors)
-        self.subscribe(ATTR_THERMOSTAT_PARAMETERS, self._handle_parameters)
+        self.subscribe(ATTR_THERMOSTAT_SENSORS, self._handle_thermostat_sensors)
+        self.subscribe(ATTR_THERMOSTAT_PARAMETERS, self._handle_thermostat_parameters)
 
-    async def _handle_sensors(self, sensors: dict[str, Any]) -> bool:
+    async def _handle_thermostat_sensors(self, sensors: dict[str, Any]) -> bool:
         """Handle thermostat sensors.
 
         For each sensor dispatch an event with the
         sensor's name and value.
         """
         await asyncio.gather(
-            *[self.dispatch(name, value) for name, value in sensors.items()]
+            *(self.dispatch(name, value) for name, value in sensors.items())
         )
-
         return True
 
-    async def _handle_parameters(
+    async def _handle_thermostat_parameters(
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
         """Handle thermostat parameters.
@@ -47,29 +51,26 @@ class Thermostat(SubDevice):
         For each parameter dispatch an event with the
         parameter's name and value.
         """
-        for index, values in parameters:
-            description = THERMOSTAT_PARAMETERS[index]
-            name = description.name
-            if name in self.data:
-                parameter: ThermostatParameter = self.data[name]
-                parameter.values = values
-                await self.dispatch(name, parameter)
-                continue
 
-            cls = (
-                ThermostatBinaryParameter
-                if isinstance(description, ThermostatBinaryParameterDescription)
-                else ThermostatParameter
-            )
-            await self.dispatch(
-                name,
-                cls(
-                    device=self,
-                    values=values,
-                    description=description,
-                    index=index,
-                    offset=(self.index * len(parameters)),
-                ),
-            )
+        def _thermostat_parameter_events() -> Generator[Coroutine, Any, None]:
+            """Get dispatch calls for thermostat parameter events."""
+            for index, values in parameters:
+                description = THERMOSTAT_PARAMETERS[index]
+                handler = (
+                    ThermostatSwitch
+                    if isinstance(description, ThermostatSwitchDescription)
+                    else ThermostatNumber
+                )
+                yield self.dispatch(
+                    description.name,
+                    handler.create_or_update(
+                        device=self,
+                        description=description,
+                        values=values,
+                        index=index,
+                        offset=(self.index * len(parameters)),
+                    ),
+                )
 
+        await asyncio.gather(*_thermostat_parameter_events())
         return True

pyplumio/exceptions.py

@@ -11,25 +11,25 @@ class ConnectionFailedError(PyPlumIOError):
     """Raised on connection failure."""
 
 
-class UnknownDeviceError(PyPlumIOError):
-    """Raised on unsupported device."""
+class ProtocolError(PyPlumIOError):
+    """Base class for protocol-related errors."""
 
 
-class ReadError(PyPlumIOError):
+class ReadError(ProtocolError):
     """Raised on read error."""
 
 
-class FrameError(PyPlumIOError):
-    """Base class for frame errors."""
+class ChecksumError(ProtocolError):
+    """Raised on incorrect frame checksum."""
 
 
-class ChecksumError(FrameError):
-    """Raised on checksum error while parsing frame content."""
+class UnknownDeviceError(ProtocolError):
+    """Raised on unknown device."""
 
 
-class UnknownFrameError(FrameError):
+class UnknownFrameError(ProtocolError):
     """Raised on unknown frame type."""
 
 
-class FrameDataError(FrameError):
+class FrameDataError(ProtocolError):
     """Raised on incorrect frame data."""

pyplumio/filters.py

@@ -3,18 +3,49 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable
 from copy import copy
 import math
 import time
-from typing import Any, Final, SupportsFloat, TypeVar, overload
-
+from typing import (
+    Any,
+    Final,
+    Protocol,
+    SupportsFloat,
+    TypeVar,
+    overload,
+    runtime_checkable,
+)
+
+from pyplumio.helpers.event_manager import Callback
 from pyplumio.helpers.parameter import Parameter
-from pyplumio.helpers.typing import SupportsComparison, SupportsSubtraction
 
 UNDEFINED: Final = "undefined"
 TOLERANCE: Final = 0.1
 
+
+@runtime_checkable
+class SupportsSubtraction(Protocol):
+    """Supports subtraction operation."""
+
+    __slots__ = ()
+
+    def __sub__(
+        self: SupportsSubtraction, other: SupportsSubtraction
+    ) -> SupportsSubtraction:
+        """Subtract a value."""
+
+
+@runtime_checkable
+class SupportsComparison(Protocol):
+    """Supports comparison."""
+
+    __slots__ = ()
+
+    def __eq__(self: SupportsComparison, other: SupportsComparison) -> bool:
+        """Compare a value."""
+
+
 Comparable = TypeVar("Comparable", Parameter, SupportsFloat, SupportsComparison)
 
 
@@ -71,23 +102,23 @@ class Filter(ABC):
 
     __slots__ = ("_callback", "_value")
 
-    _callback: Callable[[Any], Awaitable[Any]]
+    _callback: Callback
     _value: Any
 
-    def __init__(self, callback: Callable[[Any], Awaitable[Any]]) -> None:
+    def __init__(self, callback: Callback) -> None:
         """Initialize a new filter."""
         self._callback = callback
         self._value = UNDEFINED
 
-    def __eq__(self, other: Any) -> Any:
+    def __eq__(self, other: Any) -> bool:
         """Compare callbacks."""
         if isinstance(other, Filter):
             return self._callback == other._callback
 
         if callable(other):
-            return self._callback == other
+            return bool(self._callback == other)
 
-        raise TypeError
+        return NotImplemented
 
     @abstractmethod
     async def __call__(self, new_value: Any) -> Any:
@@ -112,14 +143,14 @@ class _OnChange(Filter):
             return await self._callback(new_value)
 
 
-def on_change(callback: Callable[[Any], Awaitable[Any]]) -> _OnChange:
+def on_change(callback: Callback) -> _OnChange:
     """Return a value changed filter.
 
     A callback function will only be called if value is changed from the
     previous call.
 
     :param callback: A callback function to be awaited on value change
-    :type callback: Callable[[Any], Awaitable[Any]]
+    :type callback: Callable[[Any], Coroutine[Any, Any, Any]]
     :return: A instance of callable filter
     :rtype: _OnChange
     """
@@ -138,9 +169,7 @@ class _Debounce(Filter):
     _calls: int
     _min_calls: int
 
-    def __init__(
-        self, callback: Callable[[Any], Awaitable[Any]], min_calls: int
-    ) -> None:
+    def __init__(self, callback: Callback, min_calls: int) -> None:
         """Initialize a new debounce filter."""
         super().__init__(callback)
         self._calls = 0
@@ -161,14 +190,14 @@ class _Debounce(Filter):
             return await self._callback(new_value)
 
 
-def debounce(callback: Callable[[Any], Awaitable[Any]], min_calls: int) -> _Debounce:
+def debounce(callback: Callback, min_calls: int) -> _Debounce:
     """Return a debounce filter.
 
     A callback function will only called once value is stabilized
     across multiple filter calls.
 
     :param callback: A callback function to be awaited on value change
-    :type callback: Callable[[Any], Awaitable[Any]]
+    :type callback: Callable[[Any], Coroutine[Any, Any, Any]]
     :param min_calls: Value shouldn't change for this amount of
         filter calls
     :type min_calls: int
@@ -190,9 +219,7 @@ class _Throttle(Filter):
     _last_called: float | None
     _timeout: float
 
-    def __init__(
-        self, callback: Callable[[Any], Awaitable[Any]], seconds: float
-    ) -> None:
+    def __init__(self, callback: Callback, seconds: float) -> None:
         """Initialize a new throttle filter."""
         super().__init__(callback)
         self._last_called = None
@@ -209,7 +236,7 @@ class _Throttle(Filter):
             return await self._callback(new_value)
 
 
-def throttle(callback: Callable[[Any], Awaitable[Any]], seconds: float) -> _Throttle:
+def throttle(callback: Callback, seconds: float) -> _Throttle:
     """Return a throttle filter.
 
     A callback function will only be called once a certain amount of
@@ -217,7 +244,7 @@ def throttle(callback: Callable[[Any], Awaitable[Any]], seconds: float) -> _Thro
 
     :param callback: A callback function that will be awaited once
         filter conditions are fulfilled
-    :type callback: Callable[[Any], Awaitable[Any]]
+    :type callback: Callable[[Any], Coroutine[Any, Any, Any]]
     :param seconds: A callback will be awaited at most once per
         this amount of seconds
     :type seconds: float
@@ -249,7 +276,7 @@ class _Delta(Filter):
                 return await self._callback(difference)
 
 
-def delta(callback: Callable[[Any], Awaitable[Any]]) -> _Delta:
+def delta(callback: Callback) -> _Delta:
     """Return a difference filter.
 
     A callback function will be called with a difference between two
@@ -257,7 +284,7 @@ def delta(callback: Callable[[Any], Awaitable[Any]]) -> _Delta:
 
     :param callback: A callback function that will be awaited with
         difference between values in two subsequent calls
-    :type callback: Callable[[Any], Awaitable[Any]]
+    :type callback: Callable[[Any], Coroutine[Any, Any, Any]]
     :return: A instance of callable filter
     :rtype: _Delta
     """
@@ -277,9 +304,7 @@ class _Aggregate(Filter):
     _last_update: float
     _timeout: float
 
-    def __init__(
-        self, callback: Callable[[Any], Awaitable[Any]], seconds: float
-    ) -> None:
+    def __init__(self, callback: Callback, seconds: float) -> None:
         """Initialize a new aggregate filter."""
         super().__init__(callback)
         self._last_update = time.monotonic()
@@ -303,7 +328,7 @@ class _Aggregate(Filter):
             return result
 
 
-def aggregate(callback: Callable[[Any], Awaitable[Any]], seconds: float) -> _Aggregate:
+def aggregate(callback: Callback, seconds: float) -> _Aggregate:
     """Return an aggregate filter.
 
     A callback function will be called with a sum of values collected
@@ -311,7 +336,7 @@ def aggregate(callback: Callable[[Any], Awaitable[Any]], seconds: float) -> _Agg
 
     :param callback: A callback function to be awaited once filter
         conditions are fulfilled
-    :type callback: Callable[[Any], Awaitable[Any]]
+    :type callback: Callable[[Any], Coroutine[Any, Any, Any]]
     :param seconds: A callback will be awaited with a sum of values
         aggregated over this amount of seconds.
     :type seconds: float
@@ -333,11 +358,7 @@ class _Custom(Filter):
 
     filter_fn: Callable[[Any], bool]
 
-    def __init__(
-        self,
-        callback: Callable[[Any], Awaitable[Any]],
-        filter_fn: Callable[[Any], bool],
-    ) -> None:
+    def __init__(self, callback: Callback, filter_fn: Callable[[Any], bool]) -> None:
         """Initialize a new custom filter."""
         super().__init__(callback)
         self._filter_fn = filter_fn
@@ -348,9 +369,7 @@ class _Custom(Filter):
             await self._callback(new_value)
 
 
-def custom(
-    callback: Callable[[Any], Awaitable[Any]], filter_fn: Callable[[Any], bool]
-) -> _Custom:
+def custom(callback: Callback, filter_fn: Callable[[Any], bool]) -> _Custom:
     """Return a custom filter.
 
     A callback function will be called when user-defined filter
@@ -359,7 +378,7 @@ def custom(
 
     :param callback: A callback function to be awaited when
         filter function return true
-    :type callback: Callable[[Any], Awaitable[Any]]
+    :type callback: Callable[[Any], Coroutine[Any, Any, Any]]
     :param filter_fn: Filter function, that will be called with a
         value and should return `True` to await filter's callback
     :type filter_fn: Callable[[Any], bool]

pyplumio/frames/__init__.py

@@ -29,9 +29,6 @@ if TYPE_CHECKING:
     from pyplumio.devices import AddressableDevice
 
 
-T = TypeVar("T")
-
-
 def bcc(data: bytes) -> int:
     """Return a block check character."""
     return reduce(lambda x, y: x ^ y, data)
@@ -112,7 +109,7 @@ class Frame(ABC):
         self._data = data if not kwargs else ensure_dict(data, kwargs)
         self._message = message
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Compare if this frame is equal to other."""
         if isinstance(other, Frame):
             return (
@@ -131,7 +128,7 @@ class Frame(ABC):
                 self._data,
             )
 
-        raise TypeError
+        return NotImplemented
 
     def __repr__(self) -> str:
         """Return a serializable string representation."""
@@ -224,7 +221,7 @@ class Frame(ABC):
         return bytes(data)
 
     @classmethod
-    async def create(cls: type[T], frame_type: int, **kwargs: Any) -> T:
+    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)
 
@@ -237,6 +234,9 @@ class Frame(ABC):
         """Decode frame message."""
 
 
+FrameT = TypeVar("FrameT", bound=Frame)
+
+
 class Request(Frame):
     """Represents a request."""
 

pyplumio/frames/messages.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from contextlib import suppress
 from typing import Any, ClassVar
 
 from pyplumio.const import (
@@ -53,12 +54,7 @@ class SensorDataMessage(Message):
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
         sensors, offset = FrameVersionsStructure(self).decode(message, offset=0)
-        try:
-            sensors[ATTR_STATE] = message[offset]
-            sensors[ATTR_STATE] = DeviceState(sensors[ATTR_STATE])
-        except ValueError:
-            pass
-
+        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)
@@ -79,5 +75,7 @@ class SensorDataMessage(Message):
             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}

pyplumio/helpers/data_types.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import socket
 import struct
-from typing import Any, ClassVar, Final
+from typing import Any, ClassVar, Final, TypeVar
 
 
 class DataType(ABC):
@@ -25,21 +25,19 @@ class DataType(ABC):
         """Return serializable string representation of the class."""
         return f"{self.__class__.__name__}(value={self._value})"
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Compare if this data type is equal to other."""
         if isinstance(other, DataType):
-            result: bool = self._value == other._value
-        else:
-            result = self._value == other
+            return bool(self._value == other._value)
 
-        return result
+        return bool(self._value == other)
 
     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
 
     @classmethod
-    def from_bytes(cls, data: bytes, offset: int = 0) -> DataType:
+    def from_bytes(cls: type[DataTypeT], data: bytes, offset: int = 0) -> DataTypeT:
         """Initialize a new data type from bytes."""
         data_type = cls()
         data_type.unpack(data[offset:])
@@ -68,6 +66,9 @@ class DataType(ABC):
         """Unpack the data."""
 
 
+DataTypeT = TypeVar("DataTypeT", bound=DataType)
+
+
 class Undefined(DataType):
     """Represents an undefined."""
 

pyplumio/helpers/event_manager.py

@@ -3,18 +3,26 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable
-from typing import Any
+from collections.abc import Callable, Coroutine
+from typing import Any, Generic, TypeVar, overload
+
+from typing_extensions import TypeAlias
 
 from pyplumio.helpers.task_manager import TaskManager
 
+Callback: TypeAlias = Callable[[Any], Coroutine[Any, Any, Any]]
+CallbackT = TypeVar("CallbackT", bound=Callback)
+T = TypeVar("T")
+
 
-class EventManager(TaskManager):
+class EventManager(TaskManager, Generic[T]):
     """Represents an event manager."""
 
-    data: dict[str, Any]
+    __slots__ = ("data", "_events", "_callbacks")
+
+    data: dict[str, T]
     _events: dict[str, asyncio.Event]
-    _callbacks: dict[str, list[Callable[[Any], Awaitable[Any]]]]
+    _callbacks: dict[str, list[Callback]]
 
     def __init__(self) -> None:
         """Initialize a new event manager."""
@@ -23,7 +31,7 @@ class EventManager(TaskManager):
         self._events = {}
         self._callbacks = {}
 
-    def __getattr__(self, name: str) -> Any:
+    def __getattr__(self, name: str) -> T:
         """Return attributes from the underlying data dictionary."""
         try:
             return self.data[name]
@@ -43,7 +51,7 @@ class EventManager(TaskManager):
         if name not in self.data:
             await asyncio.wait_for(self.create_event(name).wait(), timeout=timeout)
 
-    async def get(self, name: str, timeout: float | None = None) -> Any:
+    async def get(self, name: str, timeout: float | None = None) -> T:
         """Get the value by name.
 
         :param name: Event name or ID
@@ -57,6 +65,12 @@ class EventManager(TaskManager):
         await self.wait_for(name, timeout=timeout)
         return self.data[name]
 
+    @overload
+    def get_nowait(self, name: str, default: None = ...) -> T | None: ...
+
+    @overload
+    def get_nowait(self, name: str, default: T) -> T: ...
+
     def get_nowait(self, name: str, default: Any = None) -> Any:
         """Get the value by name without waiting.
 
@@ -75,23 +89,23 @@ class EventManager(TaskManager):
         except KeyError:
             return default
 
-    def subscribe(self, name: str, callback: Callable[[Any], Awaitable[Any]]) -> None:
+    def subscribe(self, name: str, callback: CallbackT) -> CallbackT:
         """Subscribe a callback to the event.
 
         :param name: Event name or ID
         :type name: str
         :param callback: A coroutine callback function, that will be
             awaited on the with the event data as an argument.
-        :type callback: Callable[[Any], Awaitable[Any]]
+        :type callback: Callback
+        :return: A reference to the callback, that can be used
+            with `EventManager.unsubscribe()`.
+        :rtype: Callback
         """
-        if name not in self._callbacks:
-            self._callbacks[name] = []
-
-        self._callbacks[name].append(callback)
+        callbacks = self._callbacks.setdefault(name, [])
+        callbacks.append(callback)
+        return callback
 
-    def subscribe_once(
-        self, name: str, callback: Callable[[Any], Awaitable[Any]]
-    ) -> None:
+    def subscribe_once(self, name: str, callback: Callback) -> Callback:
         """Subscribe a callback to the event once.
 
         Callback will be unsubscribed after single event.
@@ -100,17 +114,20 @@ class EventManager(TaskManager):
         :type name: str
         :param callback: A coroutine callback function, that will be
             awaited on the with the event data as an argument.
-        :type callback: Callable[[Any], Awaitable[Any]]
+        :type callback: Callback
+        :return: A reference to the callback, that can be used
+            with `EventManager.unsubscribe()`.
+        :rtype: Callback
         """
 
-        async def _callback(value: Any) -> Any:
+        async def _call_once(value: Any) -> Any:
             """Unsubscribe callback from the event and calls it."""
-            self.unsubscribe(name, _callback)
+            self.unsubscribe(name, _call_once)
             return await callback(value)
 
-        self.subscribe(name, _callback)
+        return self.subscribe(name, _call_once)
 
-    def unsubscribe(self, name: str, callback: Callable[[Any], Awaitable[Any]]) -> None:
+    def unsubscribe(self, name: str, callback: Callback) -> bool:
         """Usubscribe a callback from the event.
 
         :param name: Event name or ID
@@ -118,34 +135,37 @@ class EventManager(TaskManager):
         :param callback: A coroutine callback function, previously
             subscribed to an event using ``subscribe()`` or
             ``subscribe_once()`` methods.
-        :type callback: Callable[[Any], Awaitable[Any]]
+        :type callback: Callback
+        :return: `True` if callback is found, `False` otherwise.
+        :rtype: bool
         """
         if name in self._callbacks and callback in self._callbacks[name]:
             self._callbacks[name].remove(callback)
+            return True
+
+        return False
 
-    async def dispatch(self, name: str, value: Any) -> None:
+    async def dispatch(self, name: str, value: T) -> None:
         """Call registered callbacks and dispatch the event."""
-        if name in self._callbacks:
-            callbacks = self._callbacks[name].copy()
-            for callback in callbacks:
-                return_value = await callback(value)
-                value = return_value if return_value is not None else value
+        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
 
         self.data[name] = value
         self.set_event(name)
 
-    def dispatch_nowait(self, name: str, value: Any) -> None:
+    def dispatch_nowait(self, name: str, value: T) -> None:
         """Call a registered callbacks and dispatch the event without waiting."""
         self.create_task(self.dispatch(name, value))
 
-    async def load(self, data: dict[str, Any]) -> None:
+    async def load(self, data: dict[str, T]) -> None:
         """Load event data."""
-        self.data = data
         await asyncio.gather(
-            *[self.dispatch(name, value) for name, value in data.items()]
+            *(self.dispatch(name, value) for name, value in data.items())
         )
 
-    def load_nowait(self, data: dict[str, Any]) -> None:
+    def load_nowait(self, data: dict[str, T]) -> None:
         """Load event data without waiting."""
         self.create_task(self.load(data))