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

pyplumio/devices/mixer.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Sequence
+from collections.abc import Coroutine, Generator, Sequence
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from pyplumio.devices import AddressableDevice, SubDevice
 from pyplumio.helpers.parameter import ParameterValues
@@ -19,31 +19,35 @@ from pyplumio.structures.mixer_parameters import (
 from pyplumio.structures.mixer_sensors import ATTR_MIXER_SENSORS
 from pyplumio.structures.product_info import ATTR_PRODUCT, ProductInfo
 
+if TYPE_CHECKING:
+    from pyplumio.frames import Frame
+
 _LOGGER = logging.getLogger(__name__)
 
 
 class Mixer(SubDevice):
     """Represents an mixer."""
 
-    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 mixer."""
         super().__init__(queue, parent, index)
-        self.subscribe(ATTR_MIXER_SENSORS, self._handle_sensors)
-        self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_parameters)
+        self.subscribe(ATTR_MIXER_SENSORS, self._handle_mixer_sensors)
+        self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_mixer_parameters)
 
-    async def _handle_sensors(self, sensors: dict[str, Any]) -> bool:
+    async def _handle_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
         """Handle mixer 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_mixer_parameters(
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
         """Handle mixer parameters.
@@ -52,39 +56,41 @@ class Mixer(SubDevice):
         parameter's name and value.
         """
         product: ProductInfo = await self.parent.get(ATTR_PRODUCT)
-        for index, values in parameters:
-            try:
-                description = MIXER_PARAMETERS[product.type][index]
-            except IndexError:
-                _LOGGER.warning(
-                    (
-                        "Encountered unknown mixer parameter (%i): %s. "
-                        "Your device isn't fully compatible with this software and "
-                        "may not work properly. "
-                        "Please visit the issue tracker and open a feature "
-                        "request to support %s"
-                    ),
-                    index,
-                    values,
-                    product.model,
-                )
-                return False
 
-            name = description.name
-            if name in self.data:
-                parameter: MixerParameter = self.data[name]
-                parameter.values = values
-                await self.dispatch(name, parameter)
-                continue
+        def _mixer_parameter_events() -> Generator[Coroutine, Any, None]:
+            """Get dispatch calls for mixer parameter events."""
+            for index, values in parameters:
+                try:
+                    description = MIXER_PARAMETERS[product.type][index]
+                except IndexError:
+                    _LOGGER.warning(
+                        (
+                            "Encountered unknown mixer parameter (%i): %s. "
+                            "Your device isn't fully compatible with this software and "
+                            "may not work properly. "
+                            "Please visit the issue tracker and open a feature "
+                            "request to support %s"
+                        ),
+                        index,
+                        values,
+                        product.model,
+                    )
+                    return
 
-            cls = (
-                MixerBinaryParameter
-                if isinstance(description, MixerBinaryParameterDescription)
-                else MixerParameter
-            )
-            await self.dispatch(
-                name,
-                cls(device=self, values=values, description=description, index=index),
-            )
+                handler = (
+                    MixerBinaryParameter
+                    if isinstance(description, MixerBinaryParameterDescription)
+                    else MixerParameter
+                )
+                yield self.dispatch(
+                    description.name,
+                    handler.create_or_update(
+                        device=self,
+                        description=description,
+                        values=values,
+                        index=index,
+                    ),
+                )
 
+        await asyncio.gather(*_mixer_parameter_events())
         return True

pyplumio/devices/thermostat.py

@@ -3,8 +3,8 @@
 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
@@ -17,29 +17,33 @@ from pyplumio.structures.thermostat_parameters import (
 )
 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 = (
+                    ThermostatBinaryParameter
+                    if isinstance(description, ThermostatBinaryParameterDescription)
+                    else ThermostatParameter
+                )
+                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."""