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

{PyPlumIO-0.5.20.dist-info → PyPlumIO-0.5.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.5.20
+Version: 0.5.22
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -28,18 +28,18 @@ Requires-Dist: pyplumio[docs,test] ; extra == 'dev'
 Requires-Dist: pre-commit ==3.7.1 ; extra == 'dev'
 Requires-Dist: tomli ==2.0.1 ; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: sphinx ==7.3.7 ; extra == 'docs'
+Requires-Dist: sphinx ==7.4.0 ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme ==2.0.0 ; extra == 'docs'
 Requires-Dist: readthedocs-sphinx-search ==0.3.2 ; extra == 'docs'
 Provides-Extra: test
 Requires-Dist: codespell ==2.3.0 ; extra == 'test'
-Requires-Dist: coverage ==7.5.3 ; extra == 'test'
-Requires-Dist: mypy ==1.10.0 ; extra == 'test'
-Requires-Dist: pyserial-asyncio-fast ==0.11 ; extra == 'test'
-Requires-Dist: pytest ==8.2.1 ; extra == 'test'
+Requires-Dist: coverage ==7.6.0 ; extra == 'test'
+Requires-Dist: mypy ==1.10.1 ; extra == 'test'
+Requires-Dist: pyserial-asyncio-fast ==0.13 ; extra == 'test'
+Requires-Dist: pytest ==8.2.2 ; extra == 'test'
 Requires-Dist: pytest-asyncio ==0.23.7 ; extra == 'test'
-Requires-Dist: ruff ==0.4.7 ; extra == 'test'
-Requires-Dist: tox ==4.15.0 ; extra == 'test'
+Requires-Dist: ruff ==0.5.2 ; extra == 'test'
+Requires-Dist: tox ==4.16.0 ; extra == 'test'
 Requires-Dist: types-pyserial ==3.5.0.20240527 ; extra == 'test'
 
 # PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.

PyPlumIO-0.5.22.dist-info/RECORD

@@ -0,0 +1,60 @@
+pyplumio/__init__.py,sha256=ditJTIOFGJDg60atHzOpiggdUrZHpSynno7MtpZUGVk,3299
+pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
+pyplumio/_version.py,sha256=7uyNQzq4TwYgrtNcQJPZodOcwZA-26alCK4Ab94ma2M,413
+pyplumio/connection.py,sha256=QefTnJyMfFQV4f9TLRdkgP2aE9AmMjjfpFADQXgQqDE,6002
+pyplumio/const.py,sha256=8rpiVbVb5R_6Rm6J2sgCnaVrkD-2Fzhd1RYMz0MBgwo,3915
+pyplumio/exceptions.py,sha256=Wn-y5AJ5xfaBlHhTUVKB27_0Us8_OVHqh-sicnr9sYA,700
+pyplumio/filters.py,sha256=IZkvrRAHdv6s3CplK73mHomRHpo3rnoyX2u26FVr9XU,11386
+pyplumio/protocol.py,sha256=m2yPMXT2TcV-bv0jOQnwoanCpypYYh9fh7eZVOg7KTM,8108
+pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyplumio/stream.py,sha256=IVCQFKBtRafRgUkr93p_wN5mXZAD3Jw1d091dfEIK20,4479
+pyplumio/utils.py,sha256=TnBzRopinyp92wruguijxcIYmaeyNVTFX0dygI5FCMU,823
+pyplumio/devices/__init__.py,sha256=nbbi65b6bYzhXdUNQjSN4ViBVoKuxcuPIPflA_C_UME,6584
+pyplumio/devices/ecomax.py,sha256=Oe0_i_EvcPI12zfcKVNwL_dDeK6ipusQArzypp3LBCo,17066
+pyplumio/devices/ecoster.py,sha256=J4YtPmFmFwaq4LzYf28aMmB97cRAbMsVyUdBLGki42g,313
+pyplumio/devices/mixer.py,sha256=j3ysCnRpbzAycBQYiRi5y1mgHRH0EidKpdIVClWs6rA,3313
+pyplumio/devices/thermostat.py,sha256=kDTtoMcMAeSDf07vWnAOLh6EQuarh7HIz2W-5Eyg2j8,2649
+pyplumio/frames/__init__.py,sha256=uMjLWY0rCbCTBfXafA_TSfLORYBT0wLyhHSZEePsRxw,7504
+pyplumio/frames/messages.py,sha256=7vyOjcxGDnaRlyB4jPsCt00yCc3Axme8NN7uK922DS8,3622
+pyplumio/frames/requests.py,sha256=Ra8xH5oKYhkEUtadN-9ZsJKkt5xZkz5O7edQVsDhNsM,7221
+pyplumio/frames/responses.py,sha256=j4awA2-MfsoPdENC4Fvae4_Oa70rDhH19ebmEoAqhh8,6532
+pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
+pyplumio/helpers/data_types.py,sha256=5yxHCnsoKLw5kBM3s6SxwsuKs1C0yK2khyeSrrPXQsQ,8255
+pyplumio/helpers/event_manager.py,sha256=PW1cczTVHx4VBGWtBbqT7Ay6G5vSQTb_WFCkJp4HZ8o,6195
+pyplumio/helpers/factory.py,sha256=eiTkYUCernUn0VNDDdEN4IyjNPrXK8vnJESXyLaqFzE,1017
+pyplumio/helpers/parameter.py,sha256=Av__MjrM4k7-AwJ71t6W1zyhMq8XdTeI2vh1-p_p1-4,9437
+pyplumio/helpers/schedule.py,sha256=-IZJ-CU4PhFlsE586wTw--ovDrTo2Hs4JneCHhc0e-Y,5013
+pyplumio/helpers/task_manager.py,sha256=HAd69yGTRL0zQsu-ywnbLu1UXiJzgHWuhYWA--vs4lQ,1181
+pyplumio/helpers/timeout.py,sha256=XM58yaz93cNsxW7Ok6hfBw8i_92HdsGFQVBhpqbCZ70,770
+pyplumio/helpers/uid.py,sha256=J7gN8i8LE0g6tfL66BJbwsQQqzBBxWx7giyvqaJh4BM,976
+pyplumio/structures/__init__.py,sha256=EjK-5qJZ0F7lpP2b6epvTMg9cIBl4Kn91nqNkEcLwTc,1299
+pyplumio/structures/alerts.py,sha256=wX58xWr1dJgZiQtEEMLRu8bcu6dTcc-aqEIY69gYGu0,3640
+pyplumio/structures/boiler_load.py,sha256=p3mOzZUU-g7A2tG_yp8podEqpI81hlsOZmHELyPNRY8,838
+pyplumio/structures/boiler_power.py,sha256=72qsvccg49FdRdXv2f2K5sGpjT7wAOLFjlIGWpO-DVg,901
+pyplumio/structures/ecomax_parameters.py,sha256=oHKjqeX1fCCJpGMs385-2qJ3ondCvpJRpj5rS06ibf8,28076
+pyplumio/structures/fan_power.py,sha256=Q5fv-7_2NVuLeQPIVIylvgN7M8-a9D8rRUE0QGjyS3w,871
+pyplumio/structures/frame_versions.py,sha256=OMWU8tjnsrRWQsMSbmCJCmiKDwBmA75BcPZ6CqvKMLc,1566
+pyplumio/structures/fuel_consumption.py,sha256=_p2dI4H67Eopn7IF0Gj77A8c_8lNKhhDDAtmugxLd4s,976
+pyplumio/structures/fuel_level.py,sha256=mJpp1dnRD1wXi_6EyNX7TNXosjcr905rSHOnuZ5VD74,1069
+pyplumio/structures/lambda_sensor.py,sha256=JNSCiBJoM8Uk3OGbmFIigaLOntQST5U_UrmCpaQBlM0,1595
+pyplumio/structures/mixer_parameters.py,sha256=l4EQSEjmpjIULUWR-ulXiYWmBLTSfRoMvK8afKTVH6M,8763
+pyplumio/structures/mixer_sensors.py,sha256=O91929Ts1YXFmKdPRc1r_BYDgrqkv5QVtE1nGzLpuAI,2260
+pyplumio/structures/modules.py,sha256=ukju4TQmRRJfgl94QU4zytZLU5px8nw3sgfSLn9JysU,2520
+pyplumio/structures/network_info.py,sha256=rxGoTdjlUmgEzR4BjOh9XQgEqKI6OSIbhOJ8tsXocts,4063
+pyplumio/structures/output_flags.py,sha256=07N0kxlvR5WZAURuChk_BqSiXR8eaQrtI5qlkgCf4Yc,1345
+pyplumio/structures/outputs.py,sha256=1xsJPkjN643-aFawqVoupGatUIUJfQG_g252n051Qi0,1916
+pyplumio/structures/pending_alerts.py,sha256=Uq9WpB4MW9AhDkqmDhk-g0J0h4pVq0Q50z12dYEv6kY,739
+pyplumio/structures/product_info.py,sha256=uiEN6DFQlzmBvQByTirFzXQShoex0YGdFS9WI-MAxPc,2405
+pyplumio/structures/program_version.py,sha256=p3Hzn1igxGyZ99jJjPswNGCAAQdJ5_-sgZPIy-MGISI,2506
+pyplumio/structures/regulator_data.py,sha256=Dun3RjfHHoV2W5RTSQcAimBL0Or3O957vYQj7Pbi7CM,2309
+pyplumio/structures/regulator_data_schema.py,sha256=BMshEpiP-lwTgSkbTuow9KlxCwKwQXV0nFPcBpW0SJg,1505
+pyplumio/structures/schedules.py,sha256=-koo05nLkpKuj1ZPiC1NB_21MAFn1FzQ6VLC0DboYeg,6346
+pyplumio/structures/statuses.py,sha256=wkoynyMRr1VREwfBC6vU48kPA8ZQ83pcXuciy2xHJrk,1166
+pyplumio/structures/temperatures.py,sha256=1CDzehNmbALz1Jyt_9gZNIk52q6Wv-xQXjijVDCVYec,2337
+pyplumio/structures/thermostat_parameters.py,sha256=1QkgOnDndBMWpGa8GEJLdewLkdF8UqF03yhoVzYqYJE,7796
+pyplumio/structures/thermostat_sensors.py,sha256=ZmjWgYtTZ5M8Lnz_Q5N4JD8G3MvEmByPFjYsy6XZOmo,3177
+PyPlumIO-0.5.22.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+PyPlumIO-0.5.22.dist-info/METADATA,sha256=3u07pneJ8FCqq5Mj1WfLJQAd_iBqYRvlwC_I1vby3hI,5415
+PyPlumIO-0.5.22.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
+PyPlumIO-0.5.22.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.22.dist-info/RECORD,,

{PyPlumIO-0.5.20.dist-info → PyPlumIO-0.5.22.dist-info}/WHEEL

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

pyplumio/__init__.py

@@ -10,7 +10,7 @@ from pyplumio.exceptions import (
     ChecksumError,
     ConnectionFailedError,
     FrameDataError,
-    FrameError,
+    ProtocolError,
     PyPlumIOError,
     ReadError,
     UnknownDeviceError,
@@ -97,8 +97,8 @@ __all__ = [
     "EthernetParameters",
     "Frame",
     "FrameDataError",
-    "FrameError",
     "Protocol",
+    "ProtocolError",
     "PyPlumIOError",
     "ReadError",
     "SerialConnection",

pyplumio/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.20'
-__version_tuple__ = version_tuple = (0, 5, 20)
+__version__ = version = '0.5.22'
+__version_tuple__ = version_tuple = (0, 5, 22)

pyplumio/connection.py

@@ -131,11 +131,7 @@ class TcpConnection(Connection):
         **kwargs: Any,
     ) -> None:
         """Initialize a new TCP connection."""
-        super().__init__(
-            protocol,
-            reconnect_on_failure,
-            **kwargs,
-        )
+        super().__init__(protocol, reconnect_on_failure, **kwargs)
         self.host = host
         self.port = port
 
@@ -171,11 +167,7 @@ class SerialConnection(Connection):
         **kwargs: Any,
     ) -> None:
         """Initialize a new serial connection."""
-        super().__init__(
-            protocol,
-            reconnect_on_failure,
-            **kwargs,
-        )
+        super().__init__(protocol, reconnect_on_failure, **kwargs)
         self.device = device
         self.baudrate = baudrate
 

pyplumio/devices/__init__.py

@@ -13,8 +13,7 @@ from pyplumio.exceptions import UnknownDeviceError
 from pyplumio.frames import DataFrameDescription, Frame, Request
 from pyplumio.helpers.event_manager import EventManager
 from pyplumio.helpers.factory import create_instance
-from pyplumio.helpers.parameter import SET_RETRIES, Parameter
-from pyplumio.helpers.typing import ParameterValueType
+from pyplumio.helpers.parameter import SET_RETRIES, Parameter, ParameterValueType
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.utils import to_camelcase
 
@@ -45,9 +44,9 @@ def get_device_handler(device_type: int) -> str:
 class Device(ABC, EventManager):
     """Represents a device."""
 
-    queue: asyncio.Queue
+    queue: asyncio.Queue[Frame]
 
-    def __init__(self, queue: asyncio.Queue):
+    def __init__(self, queue: asyncio.Queue[Frame]):
         """Initialize a new device."""
         super().__init__()
         self.queue = queue
@@ -124,7 +123,7 @@ class AddressableDevice(Device, ABC):
     _network: NetworkInfo
     _setup_frames: Iterable[DataFrameDescription]
 
-    def __init__(self, queue: asyncio.Queue, network: NetworkInfo):
+    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo):
         """Initialize a new addressable device."""
         super().__init__(queue)
         self._network = network
@@ -143,19 +142,20 @@ class AddressableDevice(Device, ABC):
     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.args[1] for result in results if isinstance(result, ValueError)
+            result.args[1] for result in results if isinstance(result, BaseException)
         ]
 
-        await self.dispatch(ATTR_FRAME_ERRORS, errors)
-        await self.dispatch(ATTR_LOADED, True)
+        await asyncio.gather(
+            self.dispatch(ATTR_FRAME_ERRORS, errors), self.dispatch(ATTR_LOADED, True)
+        )
         return True
 
     async def request(
@@ -178,9 +178,7 @@ class AddressableDevice(Device, ABC):
     @classmethod
     async def create(cls, device_type: int, **kwargs: Any) -> AddressableDevice:
         """Create a device handler object."""
-        return await create_instance(
-            get_device_handler(device_type), cls=AddressableDevice, **kwargs
-        )
+        return await create_instance(get_device_handler(device_type), cls=cls, **kwargs)
 
 
 class SubDevice(Device, ABC):
@@ -189,7 +187,9 @@ class SubDevice(Device, ABC):
     parent: AddressableDevice
     index: int
 
-    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 sub-device."""
         super().__init__(queue)
         self.parent = parent

pyplumio/devices/ecomax.py

@@ -3,8 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Generator, Iterable, Sequence
-from contextlib import suppress
+from collections.abc import Coroutine, Generator, Iterable, Sequence
 import logging
 import time
 from typing import Any, ClassVar, Final
@@ -65,27 +64,38 @@ ATTR_FUEL_BURNED: Final = "fuel_burned"
 MAX_TIME_SINCE_LAST_FUEL_UPDATE_NS: Final = 300 * 1000000000
 
 SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
-    DataFrameDescription(frame_type=FrameType.REQUEST_UID, provides=ATTR_PRODUCT),
     DataFrameDescription(
-        frame_type=FrameType.REQUEST_REGULATOR_DATA_SCHEMA, provides=ATTR_REGDATA_SCHEMA
+        frame_type=FrameType.REQUEST_UID,
+        provides=ATTR_PRODUCT,
     ),
     DataFrameDescription(
-        frame_type=FrameType.REQUEST_ECOMAX_PARAMETERS, provides=ATTR_ECOMAX_PARAMETERS
+        frame_type=FrameType.REQUEST_REGULATOR_DATA_SCHEMA,
+        provides=ATTR_REGDATA_SCHEMA,
     ),
     DataFrameDescription(
-        frame_type=FrameType.REQUEST_ALERTS, provides=ATTR_TOTAL_ALERTS
+        frame_type=FrameType.REQUEST_ECOMAX_PARAMETERS,
+        provides=ATTR_ECOMAX_PARAMETERS,
     ),
     DataFrameDescription(
-        frame_type=FrameType.REQUEST_SCHEDULES, provides=ATTR_SCHEDULES
+        frame_type=FrameType.REQUEST_ALERTS,
+        provides=ATTR_TOTAL_ALERTS,
     ),
     DataFrameDescription(
-        frame_type=FrameType.REQUEST_MIXER_PARAMETERS, provides=ATTR_MIXER_PARAMETERS
+        frame_type=FrameType.REQUEST_SCHEDULES,
+        provides=ATTR_SCHEDULES,
+    ),
+    DataFrameDescription(
+        frame_type=FrameType.REQUEST_MIXER_PARAMETERS,
+        provides=ATTR_MIXER_PARAMETERS,
     ),
     DataFrameDescription(
         frame_type=FrameType.REQUEST_THERMOSTAT_PARAMETERS,
         provides=ATTR_THERMOSTAT_PARAMETERS,
     ),
-    DataFrameDescription(frame_type=FrameType.REQUEST_PASSWORD, provides=ATTR_PASSWORD),
+    DataFrameDescription(
+        frame_type=FrameType.REQUEST_PASSWORD,
+        provides=ATTR_PASSWORD,
+    ),
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -95,11 +105,11 @@ class EcoMAX(AddressableDevice):
     """Represents an ecoMAX controller."""
 
     address: ClassVar[int] = DeviceType.ECOMAX
-    _setup_frames: Iterable[DataFrameDescription] = SETUP_FRAME_TYPES
+    _setup_frames: tuple[DataFrameDescription, ...] = SETUP_FRAME_TYPES
     _frame_versions: dict[int, int]
     _fuel_burned_timestamp_ns: int
 
-    def __init__(self, queue: asyncio.Queue, network: NetworkInfo):
+    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo):
         """Initialize a new ecoMAX controller."""
         super().__init__(queue, network)
         self._frame_versions = {}
@@ -124,11 +134,10 @@ class EcoMAX(AddressableDevice):
 
     def handle_frame(self, frame: Frame) -> None:
         """Handle frame received from the ecoMAX device."""
-        if isinstance(frame, Request) and frame.frame_type in (
-            FrameType.REQUEST_CHECK_DEVICE,
-            FrameType.REQUEST_PROGRAM_VERSION,
+        if isinstance(frame, Request) and (
+            response := frame.response(data={ATTR_NETWORK: self._network})
         ):
-            self.queue.put_nowait(frame.response(data={ATTR_NETWORK: self._network}))
+            self.queue.put_nowait(response)
 
         super().handle_frame(frame)
 
@@ -149,12 +158,9 @@ class EcoMAX(AddressableDevice):
         For each index, return or create an instance of the mixer class.
         Once done, dispatch the 'mixers' event without waiting.
         """
-        mixers = self.data.setdefault(ATTR_MIXERS, {})
+        mixers: dict[int, Mixer] = self.data.setdefault(ATTR_MIXERS, {})
         for index in indexes:
-            if index not in mixers:
-                mixers[index] = Mixer(self.queue, parent=self, index=index)
-
-            yield mixers[index]
+            yield mixers.setdefault(index, Mixer(self.queue, parent=self, index=index))
 
         return self.dispatch_nowait(ATTR_MIXERS, mixers)
 
@@ -165,12 +171,11 @@ class EcoMAX(AddressableDevice):
         class. Once done, dispatch the 'thermostats' event without
         waiting.
         """
-        thermostats = self.data.setdefault(ATTR_THERMOSTATS, {})
+        thermostats: dict[int, Thermostat] = self.data.setdefault(ATTR_THERMOSTATS, {})
         for index in indexes:
-            if index not in thermostats:
-                thermostats[index] = Thermostat(self.queue, parent=self, index=index)
-
-            yield thermostats[index]
+            yield thermostats.setdefault(
+                index, Thermostat(self.queue, parent=self, index=index)
+            )
 
         return self.dispatch_nowait(ATTR_THERMOSTATS, thermostats)
 
@@ -183,41 +188,42 @@ class EcoMAX(AddressableDevice):
         and value.
         """
         product: ProductInfo = await self.get(ATTR_PRODUCT)
-        for index, values in parameters:
-            try:
-                description = ECOMAX_PARAMETERS[product.type][index]
-            except IndexError:
-                _LOGGER.warning(
-                    (
-                        "Encountered unknown ecoMAX 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"
+
+        def _ecomax_parameter_events() -> Generator[Coroutine, Any, None]:
+            """Get dispatch calls for ecoMAX parameter events."""
+            for index, values in parameters:
+                try:
+                    description = ECOMAX_PARAMETERS[product.type][index]
+                except IndexError:
+                    _LOGGER.warning(
+                        (
+                            "Encountered unknown ecoMAX 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,
+                    )
+
+                handler = (
+                    EcomaxBinaryParameter
+                    if isinstance(description, EcomaxBinaryParameterDescription)
+                    else EcomaxParameter
+                )
+                yield self.dispatch(
+                    description.name,
+                    handler.create_or_update(
+                        device=self,
+                        description=description,
+                        values=values,
+                        index=index,
                     ),
-                    index,
-                    values,
-                    product.model,
                 )
-                return False
-
-            name = description.name
-            if name in self.data:
-                parameter: EcomaxParameter = self.data[name]
-                parameter.values = values
-                await self.dispatch(name, parameter)
-                continue
-
-            cls = (
-                EcomaxBinaryParameter
-                if isinstance(description, EcomaxBinaryParameterDescription)
-                else EcomaxParameter
-            )
-            await self.dispatch(
-                name,
-                cls(device=self, values=values, description=description, index=index),
-            )
 
+        await asyncio.gather(*_ecomax_parameter_events())
         return True
 
     async def _update_frame_versions(self, versions: dict[int, int]) -> None:
@@ -237,18 +243,15 @@ class EcoMAX(AddressableDevice):
         """Calculate fuel burned since last sensor's data message."""
         current_timestamp_ns = time.perf_counter_ns()
         time_passed_ns = current_timestamp_ns - self._fuel_burned_timestamp_ns
+        self._fuel_burned_timestamp_ns = current_timestamp_ns
         if time_passed_ns >= MAX_TIME_SINCE_LAST_FUEL_UPDATE_NS:
             _LOGGER.warning(
                 "Skipping outdated fuel consumption data, was %i seconds old",
                 time_passed_ns / 1000000000,
             )
         else:
-            await self.dispatch(
-                ATTR_FUEL_BURNED,
-                fuel_consumption * time_passed_ns / (3600 * 1000000000),
-            )
-
-        self._fuel_burned_timestamp_ns = current_timestamp_ns
+            fuel_burned = fuel_consumption * time_passed_ns / (3600 * 1000000000)
+            await self.dispatch(ATTR_FUEL_BURNED, fuel_burned)
 
     async def _handle_mixer_parameters(
         self,
@@ -263,12 +266,18 @@ class EcoMAX(AddressableDevice):
         if not parameters:
             return False
 
-        for mixer in self._mixers(parameters.keys()):
-            await mixer.dispatch(ATTR_MIXER_PARAMETERS, parameters[mixer.index])
+        await asyncio.gather(
+            *(
+                mixer.dispatch(ATTR_MIXER_PARAMETERS, parameters[mixer.index])
+                for mixer in self._mixers(indexes=parameters.keys())
+            )
+        )
 
         return True
 
-    async def _handle_mixer_sensors(self, sensors: dict[int, dict[str, Any]]) -> bool:
+    async def _handle_mixer_sensors(
+        self, sensors: dict[int, dict[str, Any]] | None
+    ) -> bool:
         """Handle mixer sensors.
 
         For each sensor dispatch an event with the
@@ -278,14 +287,18 @@ class EcoMAX(AddressableDevice):
         if not sensors:
             return False
 
-        for mixer in self._mixers(sensors.keys()):
-            await mixer.dispatch(ATTR_MIXER_SENSORS, sensors[mixer.index])
+        await asyncio.gather(
+            *(
+                mixer.dispatch(ATTR_MIXER_SENSORS, sensors[mixer.index])
+                for mixer in self._mixers(indexes=sensors.keys())
+            )
+        )
 
         return True
 
     async def _add_schedules(
         self, schedules: list[tuple[int, list[list[bool]]]]
-    ) -> dict[str, Any]:
+    ) -> dict[str, Schedule]:
         """Add schedules to the dataset."""
         return {
             SCHEDULES[index]: Schedule(
@@ -306,25 +319,27 @@ class EcoMAX(AddressableDevice):
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
         """Add schedule parameters to the dataset."""
-        for index, values in parameters:
-            description = SCHEDULE_PARAMETERS[index]
-            name = description.name
-            if name in self.data:
-                parameter: ScheduleParameter = self.data[name]
-                parameter.values = values
-                await self.dispatch(name, parameter)
-                continue
-
-            cls = (
-                ScheduleBinaryParameter
-                if isinstance(description, ScheduleBinaryParameterDescription)
-                else ScheduleParameter
-            )
-            await self.dispatch(
-                name,
-                cls(device=self, values=values, description=description, index=index),
-            )
 
+        def _schedule_parameter_events() -> Generator[Coroutine, Any, None]:
+            """Get dispatch calls for schedule parameter events."""
+            for index, values in parameters:
+                description = SCHEDULE_PARAMETERS[index]
+                handler = (
+                    ScheduleBinaryParameter
+                    if isinstance(description, ScheduleBinaryParameterDescription)
+                    else ScheduleParameter
+                )
+                yield self.dispatch(
+                    description.name,
+                    handler.create_or_update(
+                        device=self,
+                        description=description,
+                        values=values,
+                        index=index,
+                    ),
+                )
+
+        await asyncio.gather(*_schedule_parameter_events())
         return True
 
     async def _handle_ecomax_sensors(self, sensors: dict[str, Any]) -> bool:
@@ -333,28 +348,21 @@ class EcoMAX(AddressableDevice):
         For each sensor dispatch an event with the sensor's name and
         value.
         """
-        for name, value in sensors.items():
-            await self.dispatch(name, value)
-
+        await asyncio.gather(
+            *(self.dispatch(name, value) for name, value in sensors.items())
+        )
         return True
 
     async def _add_ecomax_control_parameter(self, mode: DeviceState) -> None:
         """Create ecoMAX control parameter instance and dispatch an event."""
-        description = ECOMAX_CONTROL_PARAMETER
-        name = description.name
-        values = ParameterValues(
-            value=int(mode != DeviceState.OFF), min_value=0, max_value=1
-        )
-
-        if name in self.data:
-            parameter: EcomaxBinaryParameter = self.data[name]
-            parameter.values = values
-            return await self.dispatch(name, parameter)
-
         await self.dispatch(
-            name,
-            EcomaxBinaryParameter(
-                device=self, description=ECOMAX_CONTROL_PARAMETER, values=values
+            ECOMAX_CONTROL_PARAMETER.name,
+            EcomaxBinaryParameter.create_or_update(
+                description=ECOMAX_CONTROL_PARAMETER,
+                device=self,
+                values=ParameterValues(
+                    value=int(mode != DeviceState.OFF), min_value=0, max_value=1
+                ),
             ),
         )
 
@@ -371,26 +379,29 @@ class EcoMAX(AddressableDevice):
         if not parameters:
             return False
 
-        for thermostat in self._thermostats(parameters.keys()):
-            await thermostat.dispatch(
-                ATTR_THERMOSTAT_PARAMETERS, parameters[thermostat.index]
+        await asyncio.gather(
+            *(
+                thermostat.dispatch(
+                    ATTR_THERMOSTAT_PARAMETERS, parameters[thermostat.index]
+                )
+                for thermostat in self._thermostats(indexes=parameters.keys())
             )
-
+        )
         return True
 
     async def _add_thermostat_profile_parameter(
         self, values: ParameterValues | None
     ) -> EcomaxParameter | None:
         """Add thermostat profile parameter to the dataset."""
-        if values is not None:
-            return EcomaxParameter(
-                device=self, description=THERMOSTAT_PROFILE_PARAMETER, values=values
-            )
+        if not values:
+            return None
 
-        return None
+        return EcomaxParameter(
+            device=self, description=THERMOSTAT_PROFILE_PARAMETER, values=values
+        )
 
     async def _handle_thermostat_sensors(
-        self, sensors: dict[int, dict[str, Any]]
+        self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Handle thermostat sensors.
 
@@ -401,10 +412,13 @@ class EcoMAX(AddressableDevice):
         if not sensors:
             return False
 
-        for thermostat in self._thermostats(sensors.keys()):
-            await thermostat.dispatch(
-                ATTR_THERMOSTAT_SENSORS, sensors[thermostat.index]
-            )
+        await asyncio.gather(
+            *(
+                thermostat.dispatch(ATTR_THERMOSTAT_SENSORS, sensors[thermostat.index])
+                for thermostat in self._thermostats(indexes=sensors.keys())
+            ),
+            return_exceptions=True,
+        )
 
         return True
 
@@ -436,12 +450,8 @@ class EcoMAX(AddressableDevice):
 
     async def shutdown(self) -> None:
         """Shutdown tasks for the ecoMAX controller and sub-devices."""
-        mixers = self.get_nowait(ATTR_MIXERS, {})
-        thermostats = self.get_nowait(ATTR_THERMOSTATS, {})
-        for subdevice in (mixers | thermostats).values():
-            await subdevice.shutdown()
-
-        with suppress(AttributeError):
-            await self.regdata.shutdown()
-
+        mixers: dict[str, Mixer] = self.get_nowait(ATTR_MIXERS, {})
+        thermostats: dict[str, Thermostat] = self.get_nowait(ATTR_THERMOSTATS, {})
+        devices = (mixers | thermostats).values()
+        await asyncio.gather(*(device.shutdown() for device in devices))
         await super().shutdown()