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

pyplumio/_version.py

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

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"
@@ -229,6 +229,4 @@ PERCENTAGE: Final = "%"
 
 STATE_ON: Final = "on"
 STATE_OFF: Final = "off"
-
-
 State: TypeAlias = Literal["on", "off"]

pyplumio/devices/__init__.py

@@ -8,14 +8,13 @@ from functools import cache
 import logging
 from typing import Any, ClassVar
 
-from pyplumio.const import ATTR_FRAME_ERRORS, ATTR_LOADED, DeviceType, FrameType, State
+from pyplumio.const import ATTR_FRAME_ERRORS, DeviceType, FrameType, State
 from pyplumio.exceptions import RequestError, UnknownDeviceError
 from pyplumio.filters import on_change
-from pyplumio.frames import DataFrameDescription, Frame, Request, is_known_frame_type
+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.structures.frame_versions import ATTR_FRAME_VERSIONS
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.utils import to_camelcase
 
@@ -126,11 +125,11 @@ class PhysicalDevice(Device, ABC):
     virtual devices associated with them via parent property.
     """
 
-    __slots__ = ("address", "_network", "_setup_frames", "_frame_versions")
+    __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:
@@ -139,20 +138,27 @@ class PhysicalDevice(Device, ABC):
         self._network = network
         self._frame_versions = {}
 
-    @event_listener(ATTR_FRAME_VERSIONS, on_change)
+    @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)
             ):
-                _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)
+                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."""
         return (
@@ -171,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:
@@ -197,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:

pyplumio/devices/ecomax.py

@@ -3,15 +3,15 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Coroutine, Generator, Iterable, Sequence
+from collections.abc import Coroutine, Generator, Iterable
 import logging
 import time
 from typing import Any, Final
 
 from pyplumio.const import (
+    ATTR_FRAME_ERRORS,
     ATTR_PASSWORD,
     ATTR_SENSORS,
-    ATTR_STATE,
     STATE_OFF,
     STATE_ON,
     DeviceState,
@@ -22,6 +22,7 @@ from pyplumio.const import (
 from pyplumio.devices import PhysicalDevice
 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.helpers.event_manager import event_listener
@@ -40,14 +41,12 @@ from pyplumio.structures.ecomax_parameters import (
     ATTR_ECOMAX_CONTROL,
     ATTR_ECOMAX_PARAMETERS,
 )
-from pyplumio.structures.fuel_consumption import ATTR_FUEL_CONSUMPTION
 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
 from pyplumio.structures.schedules import (
-    ATTR_SCHEDULE_PARAMETERS,
     ATTR_SCHEDULES,
     SCHEDULE_PARAMETERS,
     SCHEDULES,
@@ -55,20 +54,53 @@ from pyplumio.structures.schedules import (
     ScheduleSwitch,
     ScheduleSwitchDescription,
 )
-from pyplumio.structures.thermostat_parameters import (
-    ATTR_THERMOSTAT_PARAMETERS,
-    ATTR_THERMOSTAT_PROFILE,
-)
+from pyplumio.structures.thermostat_parameters import ATTR_THERMOSTAT_PARAMETERS
 from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTAT_SENSORS
 
+_LOGGER = logging.getLogger(__name__)
+
+
 ATTR_MIXERS: Final = "mixers"
 ATTR_THERMOSTATS: Final = "thermostats"
 ATTR_FUEL_BURNED: Final = "fuel_burned"
 
-NANOSECONDS_IN_SECOND: Final = 1_000_000_000
-MAX_TIME_SINCE_LAST_FUEL_UPDATE_NS: Final = 300 * NANOSECONDS_IN_SECOND
+MAX_TIME_SINCE_LAST_FUEL_UPDATE: Final = 5 * 60
+
+
+class FuelMeter:
+    """Represents a fuel meter.
+
+    Calculates the fuel burned based on the time
+    elapsed since the last sensor message, which contains fuel
+    consumption data. If the elapsed time is within the acceptable
+    range, it returns the fuel burned data. Otherwise, it logs a
+    warning and returns None.
+    """
+
+    __slots__ = ("_last_update_time",)
+
+    _last_update_time: float
 
-SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
+    def __init__(self) -> None:
+        """Initialize a new fuel meter."""
+        self._last_update_time = time.monotonic()
+
+    def calculate(self, fuel_consumption: float) -> float | None:
+        """Calculate the amount of burned fuel since last update."""
+        current_time = time.monotonic()
+        time_since_update = current_time - self._last_update_time
+        self._last_update_time = current_time
+        if time_since_update < MAX_TIME_SINCE_LAST_FUEL_UPDATE:
+            return fuel_consumption * (time_since_update / 3600)
+
+        _LOGGER.warning(
+            "Skipping outdated fuel consumption data (was %f seconds old)",
+            time_since_update,
+        )
+        return None
+
+
+REQUIRED: tuple[DataFrameDescription, ...] = (
     DataFrameDescription(
         frame_type=FrameType.REQUEST_UID,
         provides=ATTR_PRODUCT,
@@ -103,28 +135,22 @@ SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
     ),
 )
 
-_LOGGER = logging.getLogger(__name__)
+REQUIRED_TYPES = [description.frame_type for description in REQUIRED]
 
 
 class EcoMAX(PhysicalDevice):
     """Represents an ecoMAX controller."""
 
-    __slots__ = ("_fuel_burned_time_ns",)
+    __slots__ = ("_fuel_meter",)
 
-    address = DeviceType.ECOMAX
-    _setup_frames = SETUP_FRAME_TYPES
+    _fuel_meter: FuelMeter
 
-    _fuel_burned_time_ns: int
+    address = DeviceType.ECOMAX
 
     def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
         """Initialize a new ecoMAX controller."""
         super().__init__(queue, network)
-        self._fuel_burned_time_ns = time.perf_counter_ns()
-
-    async def async_setup(self) -> bool:
-        """Set up an ecoMAX controller."""
-        await self.wait_for(ATTR_SENSORS)
-        return await super().async_setup()
+        self._fuel_meter = FuelMeter()
 
     def handle_frame(self, frame: Frame) -> None:
         """Handle frame received from the ecoMAX device."""
@@ -162,6 +188,13 @@ class EcoMAX(PhysicalDevice):
 
         return self.dispatch_nowait(ATTR_THERMOSTATS, thermostats)
 
+    async def _request_frame_version(
+        self, frame_type: FrameType | int, version: int
+    ) -> None:
+        """Request frame version from the device."""
+        if frame_type not in REQUIRED_TYPES:
+            await super()._request_frame_version(frame_type, version)
+
     async def _set_ecomax_state(self, state: State) -> bool:
         """Try to set the ecoMAX control state."""
         try:
@@ -196,11 +229,34 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*(device.shutdown() for device in devices))
         await super().shutdown()
 
-    @event_listener(ATTR_ECOMAX_PARAMETERS)
+    @event_listener
+    async def on_event_setup(self, setup: bool) -> None:
+        """Request frames required to set up an ecoMAX entry."""
+        _LOGGER.info("Setting up device entry")
+        await self.wait_for(ATTR_SENSORS)
+        results = await asyncio.gather(
+            *(
+                self.request(description.provides, description.frame_type)
+                for description in REQUIRED
+            ),
+            return_exceptions=True,
+        )
+
+        errors = [
+            result.frame_type for result in results if isinstance(result, RequestError)
+        ]
+
+        if errors:
+            self.dispatch_nowait(ATTR_FRAME_ERRORS, errors)
+
+        _LOGGER.info("Device entry setup done")
+
+    @event_listener
     async def on_event_ecomax_parameters(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
+        self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update ecoMAX parameters and dispatch the events."""
+        _LOGGER.info("Received device parameters")
         product_info: ProductInfo = await self.get(ATTR_PRODUCT)
 
         def _ecomax_parameter_events() -> Generator[Coroutine, Any, None]:
@@ -236,37 +292,20 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*_ecomax_parameter_events())
         return True
 
-    @event_listener(ATTR_FUEL_CONSUMPTION)
+    @event_listener
     async def on_event_fuel_consumption(self, fuel_consumption: float) -> None:
-        """Update the amount of burned fuel.
-
-        This method calculates the fuel burned based on the time
-        elapsed since the last sensor message, which contains fuel
-        consumption data. If the elapsed time is within the acceptable
-        range, it dispatches the fuel burned data. Otherwise, it logs a
-        warning and skips the outdated data.
-        """
-        time_ns = time.perf_counter_ns()
-        nanoseconds_passed = time_ns - self._fuel_burned_time_ns
-        self._fuel_burned_time_ns = time_ns
-        if nanoseconds_passed < MAX_TIME_SINCE_LAST_FUEL_UPDATE_NS:
-            return self.dispatch_nowait(
-                ATTR_FUEL_BURNED,
-                fuel_consumption * nanoseconds_passed / (3600 * NANOSECONDS_IN_SECOND),
-            )
-
-        _LOGGER.warning(
-            "Skipping outdated fuel consumption data: %f (was %i seconds old)",
-            fuel_consumption,
-            nanoseconds_passed / NANOSECONDS_IN_SECOND,
-        )
+        """Update the amount of burned fuel."""
+        fuel_burned = self._fuel_meter.calculate(fuel_consumption)
+        if fuel_burned is not None:
+            self.dispatch_nowait(ATTR_FUEL_BURNED, fuel_burned)
 
-    @event_listener(ATTR_MIXER_PARAMETERS)
+    @event_listener
     async def on_event_mixer_parameters(
         self,
-        parameters: dict[int, Sequence[tuple[int, ParameterValues]]] | None,
+        parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
     ) -> bool:
         """Handle mixer parameters and dispatch the events."""
+        _LOGGER.info("Received mixer parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -278,11 +317,12 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    @event_listener(ATTR_MIXER_SENSORS)
+    @event_listener
     async def on_event_mixer_sensors(
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Update mixer sensors and dispatch the events."""
+        _LOGGER.info("Received mixer sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -294,9 +334,9 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    @event_listener(ATTR_SCHEDULE_PARAMETERS)
+    @event_listener
     async def on_event_schedule_parameters(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
+        self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update schedule parameters and dispatch the events."""
 
@@ -319,20 +359,22 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*_schedule_parameter_events())
         return True
 
-    @event_listener(ATTR_SENSORS)
+    @event_listener
     async def on_event_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update ecoMAX sensors and dispatch the events."""
+        _LOGGER.info("Received device sensors")
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
         return True
 
-    @event_listener(ATTR_THERMOSTAT_PARAMETERS)
+    @event_listener
     async def on_event_thermostat_parameters(
         self,
-        parameters: dict[int, Sequence[tuple[int, ParameterValues]]] | None,
+        parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
     ) -> bool:
         """Handle thermostat parameters and dispatch the events."""
+        _LOGGER.info("Received thermostat parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -346,7 +388,7 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    @event_listener(ATTR_THERMOSTAT_PROFILE)
+    @event_listener
     async def on_event_thermostat_profile(
         self, values: ParameterValues | None
     ) -> EcomaxNumber | None:
@@ -358,11 +400,12 @@ class EcoMAX(PhysicalDevice):
 
         return None
 
-    @event_listener(ATTR_THERMOSTAT_SENSORS)
+    @event_listener
     async def on_event_thermostat_sensors(
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Update thermostat sensors and dispatch the events."""
+        _LOGGER.info("Received thermostat sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -377,11 +420,12 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    @event_listener(ATTR_SCHEDULES)
+    @event_listener
     async def on_event_schedules(
         self, schedules: list[tuple[int, list[list[bool]]]]
     ) -> dict[str, Schedule]:
         """Update schedules."""
+        _LOGGER.info("Received device schedules")
         return {
             SCHEDULES[index]: Schedule(
                 name=SCHEDULES[index],
@@ -397,7 +441,7 @@ class EcoMAX(PhysicalDevice):
             for index, schedule in schedules
         }
 
-    @event_listener(ATTR_STATE, on_change)
+    @event_listener(filter=on_change)
     async def on_event_state(self, state: DeviceState) -> None:
         """Update the ecoMAX control parameter."""
         await self.dispatch(

pyplumio/devices/mixer.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Coroutine, Generator, Sequence
+from collections.abc import Coroutine, Generator
 import logging
 from typing import Any
 
@@ -16,8 +16,6 @@ from pyplumio.parameters.mixer import (
     MixerSwitchDescription,
     get_mixer_parameter_types,
 )
-from pyplumio.structures.mixer_parameters import ATTR_MIXER_PARAMETERS
-from pyplumio.structures.mixer_sensors import ATTR_MIXER_SENSORS
 from pyplumio.structures.product_info import ATTR_PRODUCT, ProductInfo
 
 _LOGGER = logging.getLogger(__name__)
@@ -28,19 +26,21 @@ class Mixer(VirtualDevice):
 
     __slots__ = ()
 
-    @event_listener(ATTR_MIXER_SENSORS)
+    @event_listener
     async def on_event_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update mixer sensors and dispatch the events."""
+        _LOGGER.info("Received mixer %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
         return True
 
-    @event_listener(ATTR_MIXER_PARAMETERS)
+    @event_listener
     async def on_event_mixer_parameters(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
+        self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update mixer parameters and dispatch the events."""
+        _LOGGER.info("Received mixer %i parameters", self.index)
         product_info: ProductInfo = await self.parent.get(ATTR_PRODUCT)
 
         def _mixer_parameter_events() -> Generator[Coroutine, Any, None]:

pyplumio/devices/thermostat.py

@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Coroutine, Generator, Sequence
+from collections.abc import Coroutine, Generator
+import logging
 from typing import Any
 
 from pyplumio.devices import VirtualDevice
@@ -15,8 +16,8 @@ from pyplumio.parameters.thermostat import (
     ThermostatSwitchDescription,
     get_thermostat_parameter_types,
 )
-from pyplumio.structures.thermostat_parameters import ATTR_THERMOSTAT_PARAMETERS
-from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTAT_SENSORS
+
+_LOGGER = logging.getLogger()
 
 
 class Thermostat(VirtualDevice):
@@ -24,19 +25,21 @@ class Thermostat(VirtualDevice):
 
     __slots__ = ()
 
-    @event_listener(ATTR_THERMOSTAT_SENSORS)
+    @event_listener
     async def on_event_thermostat_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update thermostat sensors and dispatch the events."""
+        _LOGGER.info("Received thermostat %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
         return True
 
-    @event_listener(ATTR_THERMOSTAT_PARAMETERS)
+    @event_listener
     async def on_event_thermostat_parameters(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
+        self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update thermostat parameters and dispatch the events."""
+        _LOGGER.info("Received thermostat %i parameters", self.index)
 
         def _thermostat_parameter_events() -> Generator[Coroutine, Any, None]:
             """Get dispatch calls for thermostat parameter events."""

pyplumio/filters.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from contextlib import suppress
 from copy import copy
+from decimal import Decimal
+import logging
 import math
 import time
 from typing import (
@@ -22,6 +25,16 @@ from typing_extensions import TypeAlias
 from pyplumio.helpers.event_manager import Callback
 from pyplumio.parameters import Parameter
 
+_LOGGER = logging.getLogger(__name__)
+
+numpy_installed = False
+with suppress(ImportError):
+    import numpy as np
+
+    _LOGGER.info("Using numpy for improved float precision")
+    numpy_installed = True
+
+
 UNDEFINED: Final = "undefined"
 TOLERANCE: Final = 0.1
 
@@ -129,44 +142,50 @@ class _Aggregate(Filter):
     """Represents an aggregate filter.
 
     Calls a callback with a sum of values collected over a specified
-    time period.
+    time period or when sample size limit reached.
     """
 
-    __slots__ = ("_sum", "_last_update", "_timeout")
+    __slots__ = ("_values", "_sample_size", "_timeout", "_last_call_time")
 
-    _sum: complex
-    _last_update: float
+    _values: list[float | int | Decimal]
+    _sample_size: int
     _timeout: float
+    _last_call_time: float
 
-    def __init__(self, callback: Callback, seconds: float) -> None:
+    def __init__(self, callback: Callback, seconds: float, sample_size: int) -> None:
         """Initialize a new aggregate filter."""
         super().__init__(callback)
-        self._last_update = time.monotonic()
+        self._last_call_time = time.monotonic()
         self._timeout = seconds
-        self._sum = 0.0
+        self._sample_size = sample_size
+        self._values = []
 
     async def __call__(self, new_value: Any) -> Any:
         """Set a new value for the callback."""
-        current_timestamp = time.monotonic()
-        try:
-            self._sum += new_value
-        except TypeError as e:
-            raise ValueError(
-                "Aggregate filter can only be used with numeric values"
-            ) from e
-
-        if current_timestamp - self._last_update >= self._timeout:
-            result = await self._callback(self._sum)
-            self._last_update = current_timestamp
-            self._sum = 0.0
+        if not isinstance(new_value, (float, int, Decimal)):
+            raise TypeError(
+                "Aggregate filter can only be used with numeric values, got "
+                f"{type(new_value).__name__}: {new_value}"
+            )
+
+        current_time = time.monotonic()
+        self._values.append(new_value)
+        time_since_call = current_time - self._last_call_time
+        if time_since_call >= self._timeout or len(self._values) >= self._sample_size:
+            result = await self._callback(
+                np.sum(self._values) if numpy_installed else sum(self._values)
+            )
+            self._last_call_time = current_time
+            self._values = []
             return result
 
 
-def aggregate(callback: Callback, seconds: float) -> _Aggregate:
+def aggregate(callback: Callback, seconds: float, sample_size: int) -> _Aggregate:
     """Create a new aggregate filter.
 
     A callback function will be called with a sum of values collected
-    over a specified time period. Can only be used with numeric values.
+    over a specified time period or when sample size limit reached.
+    Can only be used with numeric values.
 
     :param callback: A callback function to be awaited once filter
         conditions are fulfilled
@@ -174,10 +193,13 @@ def aggregate(callback: Callback, seconds: float) -> _Aggregate:
     :param seconds: A callback will be awaited with a sum of values
         aggregated over this amount of seconds.
     :type seconds: float
+    :param sample_size: The maximum number of values to aggregate
+        before calling the callback
+    :type sample_size: int
     :return: An instance of callable filter
     :rtype: _Aggregate
     """
-    return _Aggregate(callback, seconds)
+    return _Aggregate(callback, seconds, sample_size)
 
 
 class _Clamp(Filter):

pyplumio/helpers/async_cache.py

@@ -0,0 +1,48 @@
+"""Contains a simple async cache for caching results of async functions."""
+
+from collections.abc import Awaitable
+from functools import wraps
+from typing import Any, Callable, TypeVar, cast
+
+from typing_extensions import ParamSpec
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+class AsyncCache:
+    """A simple cache for asynchronous functions."""
+
+    __slots__ = ("cache",)
+
+    cache: dict[str, Any]
+
+    def __init__(self) -> None:
+        """Initialize the cache."""
+        self.cache = {}
+
+    async def get(self, key: str, coro: Callable[..., Awaitable[Any]]) -> Any:
+        """Get a value from the cache or compute and store it."""
+        if key not in self.cache:
+            self.cache[key] = await coro()
+
+        return self.cache[key]
+
+
+# Create a global cache instance
+async_cache = AsyncCache()
+
+
+def acache(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
+    """Cache the result of an async function."""
+
+    @wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        func_name = f"{func.__module__}.{func.__qualname__}"
+        key = f"{func_name}:{args}:{kwargs}"
+        return cast(T, await async_cache.get(key, lambda: func(*args, **kwargs)))
+
+    return wrapper
+
+
+__all__ = ["acache", "async_cache"]

pyplumio/helpers/event_manager.py

@@ -17,7 +17,17 @@ _CallableT: TypeAlias = Callable[..., Any]
 _CallbackT = TypeVar("_CallbackT", bound=Callback)
 
 
-def event_listener(event: str, filter: _CallableT | None = None) -> _CallableT:
+@overload
+def event_listener(name: _CallableT, filter: None = None) -> Callback: ...
+
+
+@overload
+def event_listener(
+    name: str | None = None, filter: _CallableT | None = None
+) -> _CallableT: ...
+
+
+def event_listener(name: Any = None, filter: _CallableT | None = None) -> Any:
     """Mark a function as an event listener.
 
     This decorator attaches metadata to the function, identifying it
@@ -26,11 +36,19 @@ def event_listener(event: str, filter: _CallableT | None = None) -> _CallableT:
 
     def decorator(func: _CallbackT) -> _CallbackT:
         # Attach metadata to the function to mark it as a listener.
+        event = (
+            name
+            if isinstance(name, str)
+            else func.__qualname__.split("on_event_", 1)[1]
+        )
         setattr(func, "_on_event", event)
         setattr(func, "_on_event_filter", filter)
         return func
 
-    return decorator
+    if callable(name):
+        return decorator(name)
+    else:
+        return decorator
 
 
 T = TypeVar("T")

pyplumio/helpers/timeout.py

@@ -5,19 +5,20 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Awaitable, Callable
 from functools import wraps
-from typing import Any, TypeVar
+from typing import TypeVar
 
-from typing_extensions import ParamSpec, TypeAlias
+from typing_extensions import ParamSpec
 
 T = TypeVar("T")
 P = ParamSpec("P")
-_CallableT: TypeAlias = Callable[..., Any]
 
 
-def timeout(seconds: float) -> _CallableT:
+def timeout(
+    seconds: float,
+) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Awaitable[T]]]:
     """Decorate a timeout for the awaitable."""
 
-    def decorator(func: Callable[P, Awaitable[T]]) -> _CallableT:
+    def decorator(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
         @wraps(func)
         async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
             return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)

pyplumio/parameters/__init__.py

@@ -196,7 +196,7 @@ class Parameter(ABC):
         self, value: int, retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Attempt to update a parameter value on the remote device."""
-        _LOGGER.debug(
+        _LOGGER.info(
             "Attempting to update '%s' parameter to %d", self.description.name, value
         )
         if value == self.values.value:
@@ -509,8 +509,8 @@ def patch_parameter_types(
     """Patch the parameter types based on the provided overrides.
 
     Note:
-        The `# type: ignore[assignment]` comment is used to suppress a type-checking
-        error caused by mypy bug. For more details, see:
+        The `# type: ignore[assignment]` comment is used to suppress a
+        type-checking error caused by mypy bug. For more details, see:
         https://github.com/python/mypy/issues/13596
 
     """
@@ -522,6 +522,12 @@ def patch_parameter_types(
     }
     for index, description in enumerate(parameter_types):
         if description.name in replacements:
+            _LOGGER.info(
+                "Replacing parameter description for '%s' with '%s' (%s)",
+                description.name,
+                replacements[description.name],
+                product_info.model,
+            )
             parameter_types[index] = replacements[description.name]  # type: ignore[assignment]
 
     return parameter_types

pyplumio/protocol.py

@@ -10,11 +10,12 @@ import logging
 
 from typing_extensions import TypeAlias
 
-from pyplumio.const import ATTR_CONNECTED, DeviceType
+from pyplumio.const import ATTR_CONNECTED, ATTR_SETUP, DeviceType
 from pyplumio.devices import PhysicalDevice
 from pyplumio.exceptions import ProtocolError
 from pyplumio.frames import Frame
 from pyplumio.frames.requests import StartMasterRequest
+from pyplumio.helpers.async_cache import acache
 from pyplumio.helpers.event_manager import EventManager
 from pyplumio.stream import FrameReader, FrameWriter
 from pyplumio.structures.network_info import (
@@ -132,6 +133,7 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     consumers_count: int
     _network: NetworkInfo
     _queues: Queues
+    _entry_lock: asyncio.Lock
 
     def __init__(
         self,
@@ -147,6 +149,7 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             wlan=wireless_parameters or WirelessParameters(status=False),
         )
         self._queues = Queues(read=asyncio.Queue(), write=asyncio.Queue())
+        self._entry_lock = asyncio.Lock()
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -224,18 +227,23 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             device.handle_frame(frame)
             queue.task_done()
 
+    @acache
     async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
-        """Set up or return a device entry."""
-        name = device_type.name.lower()
-        if name not in self.data:
+        """Return the device entry."""
+
+        @acache
+        async def _setup_device_entry(device_type: DeviceType) -> PhysicalDevice:
+            """Set up the device entry."""
             device = await PhysicalDevice.create(
                 device_type, queue=self._queues.write, network=self._network
             )
             device.dispatch_nowait(ATTR_CONNECTED, True)
-            self.create_task(device.async_setup(), name=f"device_setup_task ({name})")
-            await self.dispatch(name, device)
+            device.dispatch_nowait(ATTR_SETUP, True)
+            self.dispatch_nowait(device_type.name.lower(), device)
+            return device
 
-        return self.data[name]
+        async with self._entry_lock:
+            return await _setup_device_entry(device_type)
 
 
 __all__ = ["Protocol", "DummyProtocol", "AsyncProtocol"]

pyplumio/structures/alerts.py

@@ -10,7 +10,7 @@ from functools import lru_cache
 from typing import Any, Final, Literal, NamedTuple
 
 from pyplumio.const import AlertType
-from pyplumio.helpers.data_types import UnsignedInt
+from pyplumio.data_types import UnsignedInt
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/boiler_power.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import math
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import Float
+from pyplumio.data_types import Float
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/fan_power.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import math
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import Float
+from pyplumio.data_types import Float
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/frame_versions.py

@@ -6,7 +6,7 @@ from contextlib import suppress
 from typing import Any, Final
 
 from pyplumio.const import FrameType
-from pyplumio.helpers.data_types import UnsignedShort
+from pyplumio.data_types import UnsignedShort
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/fuel_consumption.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import math
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import Float
+from pyplumio.data_types import Float
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/lambda_sensor.py

@@ -7,7 +7,7 @@ import math
 from typing import Any, Final
 
 from pyplumio.const import BYTE_UNDEFINED, LambdaState
-from pyplumio.helpers.data_types import UnsignedShort
+from pyplumio.data_types import UnsignedShort
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/mixer_sensors.py

@@ -7,7 +7,7 @@ import math
 from typing import Any, Final
 
 from pyplumio.const import ATTR_CURRENT_TEMP, ATTR_TARGET_TEMP
-from pyplumio.helpers.data_types import Float
+from pyplumio.data_types import Float
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/network_info.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 from typing import Any, Final
 
 from pyplumio.const import EncryptionType
-from pyplumio.helpers.data_types import IPv4, VarString
+from pyplumio.data_types import IPv4, VarString
 from pyplumio.structures import Structure
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/output_flags.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import UnsignedInt
+from pyplumio.data_types import UnsignedInt
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/outputs.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import UnsignedInt
+from pyplumio.data_types import UnsignedInt
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/product_info.py

@@ -9,7 +9,7 @@ import struct
 from typing import Any, Final
 
 from pyplumio.const import ProductType
-from pyplumio.helpers.data_types import UnsignedShort, VarBytes, VarString
+from pyplumio.data_types import UnsignedShort, VarBytes, VarString
 from pyplumio.helpers.uid import unpack_uid
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict

pyplumio/structures/regulator_data.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import BitArray, DataType
+from pyplumio.data_types import BitArray, DataType
 from pyplumio.structures import StructureDecoder
 from pyplumio.structures.frame_versions import FrameVersionsStructure
 from pyplumio.structures.regulator_data_schema import ATTR_REGDATA_SCHEMA

pyplumio/structures/regulator_data_schema.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import DATA_TYPES, DataType, UnsignedShort
+from pyplumio.data_types import DATA_TYPES, DataType, UnsignedShort
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/temperatures.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import math
 from typing import Any, Final
 
-from pyplumio.helpers.data_types import Float
+from pyplumio.data_types import Float
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

pyplumio/structures/thermostat_parameters.py

@@ -52,13 +52,11 @@ class ThermostatParametersStructure(StructureDecoder):
         self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
     ) -> tuple[dict[str, Any], int]:
         """Decode bytes and return message data and offset."""
-        if (device := self.frame.handler) is not None and (
-            thermostats := device.get_nowait(ATTR_THERMOSTATS_AVAILABLE, 0)
-        ) == 0:
-            return (
-                ensure_dict(data, {ATTR_THERMOSTAT_PARAMETERS: None}),
-                offset,
-            )
+        device = self.frame.handler
+        if not device or not (
+            thermostats := device.get_nowait(ATTR_THERMOSTATS_AVAILABLE, None)
+        ):
+            return ensure_dict(data, {ATTR_THERMOSTAT_PARAMETERS: None}), offset
 
         start = message[offset + 1]
         end = message[offset + 2]

pyplumio/structures/thermostat_sensors.py

@@ -13,7 +13,7 @@ from pyplumio.const import (
     ATTR_TARGET_TEMP,
     BYTE_UNDEFINED,
 )
-from pyplumio.helpers.data_types import Float
+from pyplumio.data_types import Float
 from pyplumio.structures import StructureDecoder
 from pyplumio.utils import ensure_dict
 

{pyplumio-0.5.43.dist-info → pyplumio-0.5.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.43
+Version: 0.5.44
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -29,7 +29,9 @@ Requires-Dist: typing-extensions==4.13.2
 Provides-Extra: test
 Requires-Dist: codespell==2.4.1; extra == "test"
 Requires-Dist: coverage==7.8.0; extra == "test"
+Requires-Dist: freezegun==1.5.1; extra == "test"
 Requires-Dist: mypy==1.15.0; extra == "test"
+Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
 Requires-Dist: pytest==8.3.5; extra == "test"
 Requires-Dist: pytest-asyncio==0.26.0; extra == "test"

pyplumio-0.5.44.dist-info/RECORD

@@ -0,0 +1,64 @@
+pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
+pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
+pyplumio/_version.py,sha256=jmLwpXAvOwShA-gbD-jNugBDxB5dkqo8l6U4A1WR2nw,513
+pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
+pyplumio/const.py,sha256=FxF97bl_GunYuB8Wo72zCzHtznRCM64ygC2qfaR3UyA,5684
+pyplumio/data_types.py,sha256=r-QOIZiIpBFo4kRongyu8n0BHTaEU6wWMTmNkWBNjq8,9223
+pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
+pyplumio/filters.py,sha256=1AIEesbIBOceLdz--7SwDb8IPn8aLNk4gd1F6EJCZ-s,13667
+pyplumio/protocol.py,sha256=UnrXDouo4dDi7hqwJYHoEAvCoYJs3PgP1DFBBwRqBrw,8427
+pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyplumio/stream.py,sha256=iCB-XlNXRRE0p7nstb1AkXwVDwcCsgym_ggB_IDiJc8,4926
+pyplumio/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
+pyplumio/devices/__init__.py,sha256=dqEB8swvH5ZnY7KKyTJs9f3GR37I_0PrsY9Uet-663w,7926
+pyplumio/devices/ecomax.py,sha256=GgugaaaVHHoCrl9zGH2B5WBlMJF_CVTkRwMIe_xJuYI,16114
+pyplumio/devices/ecoster.py,sha256=X46ky5XT8jHMFq9sBW0ve8ZI_tjItQDMt4moXsW-ogY,307
+pyplumio/devices/mixer.py,sha256=cuqhWcIeGgHNIVqmRm-NyvaRb-ltGY5YZXrQN81xKP0,2744
+pyplumio/devices/thermostat.py,sha256=Wylm0xgheS6E_y-w0E8JEKax6Gckfw7qZu9fgv8iSMc,2266
+pyplumio/frames/__init__.py,sha256=5lw19oFlN89ZvO8KGwnkwERULQNYiP-hhZKk65LsjYY,7862
+pyplumio/frames/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
+pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
+pyplumio/frames/responses.py,sha256=M6Ky4gg2AoShmRXX0x6nftajxrvmQLKPVRWbwyhvI0E,6663
+pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
+pyplumio/helpers/async_cache.py,sha256=TlxpL4P3IZEobS4KyP86cEtqZghKtPWmVj57n5FpvTQ,1259
+pyplumio/helpers/event_manager.py,sha256=aKNlhsPNTy3eOSfWVb9TJxtIsN9GAQv9XxhOi_BOhlM,8097
+pyplumio/helpers/factory.py,sha256=AUPnTLDAPL8uq-fxn7ndMs_mOrocEo6keQjDk4Ig1ko,1156
+pyplumio/helpers/schedule.py,sha256=4XdijJBnhsfsj3l2hiKsrLA_a6oxTzg67ZnjG2IJlB0,5301
+pyplumio/helpers/task_manager.py,sha256=N71F6Ag1HHxdf5zJeCMcEziFdH9lmJKtMPoRGjJ-E40,1209
+pyplumio/helpers/timeout.py,sha256=ZTWMhgk5lOUNsR-qqNxUOif5rDHH1eOMAvRTngb1QH4,745
+pyplumio/helpers/uid.py,sha256=HeM5Zmd0qfNmVya6RKE-bBYzdxG-pAiViOZRHqw33VU,1011
+pyplumio/parameters/__init__.py,sha256=kEDaPqJLRemc6puIGThmjfAbdt86oZnXIUE34scXG5Q,16603
+pyplumio/parameters/ecomax.py,sha256=MfjiXYW_MoEPMPdmeeZi2Wb8tNhZKTHXYxSBCQNYf9g,27606
+pyplumio/parameters/mixer.py,sha256=RjhfUU_62STyNV0Ud9A4G4FEvVwo02qGVl8h1QvqQXI,6646
+pyplumio/parameters/thermostat.py,sha256=-DK2Mb78CGrKmdhwAD0M3GiGJatczPnl1e2gVeT19tI,5070
+pyplumio/structures/__init__.py,sha256=emZVH5OFgdTUPbEJoznMKitmK0nlPm0I4SmF86It1Do,1345
+pyplumio/structures/alerts.py,sha256=fglFcxHoZ3hZJscPHmbJJqTr2mH8YXRW0T18L4Dirds,3692
+pyplumio/structures/boiler_load.py,sha256=e-6itp9L6iJeeOyhSTiOclHLuYmqG7KkcepsHwJSQSI,894
+pyplumio/structures/boiler_power.py,sha256=7CdOk-pYLEpy06oRBAeichvq8o-a2RcesB0tzo9ccBs,951
+pyplumio/structures/ecomax_parameters.py,sha256=E_s5bO0RqX8p1rM5DtYAsEXcHqS8P6Tg4AGm21cxsnM,1663
+pyplumio/structures/fan_power.py,sha256=l9mDB_Ugnn1gKJFh9fppwzoi0i1_3eBvHAD6uPAdiDI,915
+pyplumio/structures/frame_versions.py,sha256=n-L93poxY3i_l3oMWg0PzRXGrkY9cgv-Eyuf9XObaR4,1602
+pyplumio/structures/fuel_consumption.py,sha256=Cf3Z14gEZnkVEt-OAXNka3-T8fKIMHQaVSeQdQYXnPg,1034
+pyplumio/structures/fuel_level.py,sha256=-zUKApVJaZZzc1q52vqO3K2Mya43c6vRgw45d2xgy5Q,1123
+pyplumio/structures/lambda_sensor.py,sha256=0ZNEhzvNVtZt9CY0ZnZ7-N3fdWnuuexcrkztKq-lBSw,1708
+pyplumio/structures/mixer_parameters.py,sha256=JMSySqI7TUGKdFtDp1P5DJm5EAbijMSz-orRrAe1KlQ,2041
+pyplumio/structures/mixer_sensors.py,sha256=ChgLhC3p4fyoPy1EKe0BQTvXOPZEISbcK2HyamrNaN8,2450
+pyplumio/structures/modules.py,sha256=LviFz3_pPvSQ5i_Mr2S9o5miVad8O4qn48CR_z7yG24,2791
+pyplumio/structures/network_info.py,sha256=HYhROSMbVxqYxsOa7aF3xetQXEs0xGvhzH-4OHETZVQ,4327
+pyplumio/structures/output_flags.py,sha256=upVIgAH2JNncHFXvjE-t6oTFF-JNwwZbyGjfrcKWtz0,1508
+pyplumio/structures/outputs.py,sha256=3NP5lArzQiihRC4QzBuWAHL9hhjvGxNkKmeoYZnDD-0,2291
+pyplumio/structures/pending_alerts.py,sha256=b1uMmDHTGv8eE0h1vGBrKsPxlwBmUad7HgChnDDLK_g,801
+pyplumio/structures/product_info.py,sha256=yXHFQv6LcA7kj8ErAY-fK4z33EIgDnvVDNe3Dccg_Bo,2472
+pyplumio/structures/program_version.py,sha256=qHmmPComCOa-dgq7cFAucEGuRS-jWYwWi40VCiPS7cc,2621
+pyplumio/structures/regulator_data.py,sha256=SYKI1YPC3mDAth-SpYejttbD0IzBfobjgC-uy_uUKnw,2333
+pyplumio/structures/regulator_data_schema.py,sha256=0SapbZCGzqAHmHC7dwhufszJ9FNo_ZO_XMrFGNiUe-w,1547
+pyplumio/structures/schedules.py,sha256=JWMyi-D_a2M8k17Zis7-o9L3Zn-Lvzdh1ewXDQeoaYo,7092
+pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8pLI,1325
+pyplumio/structures/temperatures.py,sha256=2VD3P_vwp9PEBkOn2-WhifOR8w-UYNq35aAxle0z2Vg,2831
+pyplumio/structures/thermostat_parameters.py,sha256=st3x3HkjQm3hqBrn_fpvPDQu8fuc-Sx33ONB19ViQak,3007
+pyplumio/structures/thermostat_sensors.py,sha256=rO9jTZWGQpThtJqVdbbv8sYMYHxJi4MfwZQza69L2zw,3399
+pyplumio-0.5.44.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.44.dist-info/METADATA,sha256=ShYqD3uUOfz0g4IhgAT1fA15CjI9RtXViXYY238Nsuo,5611
+pyplumio-0.5.44.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+pyplumio-0.5.44.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.44.dist-info/RECORD,,

{pyplumio-0.5.43.dist-info → pyplumio-0.5.44.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyplumio-0.5.43.dist-info/RECORD

@@ -1,63 +0,0 @@
-pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
-pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=AtaNtvbmZhmRRCLmwQp9AiFD_qy1xi0FmP9tZWoRRsg,513
-pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
-pyplumio/const.py,sha256=efsoFXbja8oFhn0fiATnHsNKhV26z0XdWHn84MHc1pE,5688
-pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
-pyplumio/filters.py,sha256=Z_U3V7VEBkCwXWcAy9zmauoZtQj7BSCEODzQhT9K2tc,12784
-pyplumio/protocol.py,sha256=oyZZKVazLTlS1sMKQA4zThp39-HqIGXW7BUGctHznN4,8146
-pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=iCB-XlNXRRE0p7nstb1AkXwVDwcCsgym_ggB_IDiJc8,4926
-pyplumio/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
-pyplumio/devices/__init__.py,sha256=70MJSd43ipd6V0E7az0Ba_5JKTX3ICE3Ct-GDX8GTzU,8370
-pyplumio/devices/ecomax.py,sha256=_lAMMZw9hW1KEKXREgaOZTIsvBPss_fDGjB44GZNXUM,15005
-pyplumio/devices/ecoster.py,sha256=X46ky5XT8jHMFq9sBW0ve8ZI_tjItQDMt4moXsW-ogY,307
-pyplumio/devices/mixer.py,sha256=YLe_3XCjjX0PHrICPT-dR7uelTTFofHlqC8twtg8Wyg,2810
-pyplumio/devices/thermostat.py,sha256=OYWYBl-8R7ooTgAQSHkhwHH74Rjjh8IJJZNyi93omgg,2306
-pyplumio/frames/__init__.py,sha256=5lw19oFlN89ZvO8KGwnkwERULQNYiP-hhZKk65LsjYY,7862
-pyplumio/frames/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
-pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
-pyplumio/frames/responses.py,sha256=M6Ky4gg2AoShmRXX0x6nftajxrvmQLKPVRWbwyhvI0E,6663
-pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
-pyplumio/helpers/data_types.py,sha256=r-QOIZiIpBFo4kRongyu8n0BHTaEU6wWMTmNkWBNjq8,9223
-pyplumio/helpers/event_manager.py,sha256=J-y5ErPvR2ek3rhYrASElwgtCaEM6wuELJQqH74VIWY,7686
-pyplumio/helpers/factory.py,sha256=AUPnTLDAPL8uq-fxn7ndMs_mOrocEo6keQjDk4Ig1ko,1156
-pyplumio/helpers/schedule.py,sha256=4XdijJBnhsfsj3l2hiKsrLA_a6oxTzg67ZnjG2IJlB0,5301
-pyplumio/helpers/task_manager.py,sha256=N71F6Ag1HHxdf5zJeCMcEziFdH9lmJKtMPoRGjJ-E40,1209
-pyplumio/helpers/timeout.py,sha256=nbro-58ncTCI___kMtE221_UVwNXtqt-oY4Dc5sx_Dg,728
-pyplumio/helpers/uid.py,sha256=HeM5Zmd0qfNmVya6RKE-bBYzdxG-pAiViOZRHqw33VU,1011
-pyplumio/parameters/__init__.py,sha256=1K4TzQ3qhTX7Slixap_PW4N38d1whgXm13mNwjRuw-s,16371
-pyplumio/parameters/ecomax.py,sha256=MfjiXYW_MoEPMPdmeeZi2Wb8tNhZKTHXYxSBCQNYf9g,27606
-pyplumio/parameters/mixer.py,sha256=RjhfUU_62STyNV0Ud9A4G4FEvVwo02qGVl8h1QvqQXI,6646
-pyplumio/parameters/thermostat.py,sha256=-DK2Mb78CGrKmdhwAD0M3GiGJatczPnl1e2gVeT19tI,5070
-pyplumio/structures/__init__.py,sha256=emZVH5OFgdTUPbEJoznMKitmK0nlPm0I4SmF86It1Do,1345
-pyplumio/structures/alerts.py,sha256=teoUlbhvpnPLntPXCRmNO7YZa0RxvPBD724mqxkQD28,3700
-pyplumio/structures/boiler_load.py,sha256=e-6itp9L6iJeeOyhSTiOclHLuYmqG7KkcepsHwJSQSI,894
-pyplumio/structures/boiler_power.py,sha256=Nxc8DiOQRD6dr3fo-xxiu171t9ablYJIRL8RQe0SEzo,959
-pyplumio/structures/ecomax_parameters.py,sha256=E_s5bO0RqX8p1rM5DtYAsEXcHqS8P6Tg4AGm21cxsnM,1663
-pyplumio/structures/fan_power.py,sha256=MwiaU8ht8BLSaGLw5dQvVleDcHCtyrvO1DT9iX0oxlg,923
-pyplumio/structures/frame_versions.py,sha256=MS5bLW1y3SRq6Swjd1mkzy9xJkBXYQq313XAY1RnMjc,1610
-pyplumio/structures/fuel_consumption.py,sha256=Ki_i_T4fq--6F8d4spXuY13JEYZllGwcU5U589mwuKo,1042
-pyplumio/structures/fuel_level.py,sha256=-zUKApVJaZZzc1q52vqO3K2Mya43c6vRgw45d2xgy5Q,1123
-pyplumio/structures/lambda_sensor.py,sha256=ySSSsN5BHvvvZgJX2rh7K_cdfW0QI_uGH-l2XqWJmmQ,1716
-pyplumio/structures/mixer_parameters.py,sha256=JMSySqI7TUGKdFtDp1P5DJm5EAbijMSz-orRrAe1KlQ,2041
-pyplumio/structures/mixer_sensors.py,sha256=B7jBL4KPE3lCh9TX_mLcsOCdabKbgudu4FJSWqud1QE,2458
-pyplumio/structures/modules.py,sha256=LviFz3_pPvSQ5i_Mr2S9o5miVad8O4qn48CR_z7yG24,2791
-pyplumio/structures/network_info.py,sha256=EpqCaHY7V3gVzZ04STy08vv7RUdtI9tUAhWWlqBnMMQ,4335
-pyplumio/structures/output_flags.py,sha256=sqZm-jJC9MuJM1qezMh59wan7MUpqEXgahdHc0nzmYY,1516
-pyplumio/structures/outputs.py,sha256=9S7Cvc6Jjy1kLgV4d5SNY2suWrUo4gwbp7PDoAdGhkA,2299
-pyplumio/structures/pending_alerts.py,sha256=b1uMmDHTGv8eE0h1vGBrKsPxlwBmUad7HgChnDDLK_g,801
-pyplumio/structures/product_info.py,sha256=IwEfXQ6LGyhoh3ox_i8dRurT0gKJfQdhYln76Q268TI,2480
-pyplumio/structures/program_version.py,sha256=qHmmPComCOa-dgq7cFAucEGuRS-jWYwWi40VCiPS7cc,2621
-pyplumio/structures/regulator_data.py,sha256=H5vg70EV_OkJ6Np3qkQ-ekXYdzHH5S2YGv9SGfpXRhY,2341
-pyplumio/structures/regulator_data_schema.py,sha256=dY3YeaTfwbhz3jyvYtSLJBxyASDqPZsEeGIHN_Rbew0,1555
-pyplumio/structures/schedules.py,sha256=JWMyi-D_a2M8k17Zis7-o9L3Zn-Lvzdh1ewXDQeoaYo,7092
-pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8pLI,1325
-pyplumio/structures/temperatures.py,sha256=xm_UETl0tqhoIeIjEESQQkAvE3oU5zjJLxgek2SqEag,2839
-pyplumio/structures/thermostat_parameters.py,sha256=5xlsDkb0Bh5pAodZDiLp3ojM__mWAz4XQ3fmwfs-o0c,3051
-pyplumio/structures/thermostat_sensors.py,sha256=oUcyTPMuq8GpPc2HnVh2wpNC5QNNMj82WF6bsU58MFA,3407
-pyplumio-0.5.43.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.43.dist-info/METADATA,sha256=ZnTjSCqiyRG_d_siYFQn5XRvGLRUT28gsg7Rswo0hU4,5510
-pyplumio-0.5.43.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-pyplumio-0.5.43.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.43.dist-info/RECORD,,