PyPlumIO 0.5.43__tar.gz → 0.5.49__tar.gz

{pyplumio-0.5.43 → pyplumio-0.5.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.43
+Version: 0.5.49
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -29,11 +29,13 @@ 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"
-Requires-Dist: ruff==0.11.7; extra == "test"
+Requires-Dist: ruff==0.11.9; extra == "test"
 Requires-Dist: tox==4.25.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20250326; extra == "test"
 Provides-Extra: docs

{pyplumio-0.5.43 → pyplumio-0.5.49}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.43
+Version: 0.5.49
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -29,11 +29,13 @@ 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"
-Requires-Dist: ruff==0.11.7; extra == "test"
+Requires-Dist: ruff==0.11.9; extra == "test"
 Requires-Dist: tox==4.25.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20250326; extra == "test"
 Provides-Extra: docs

{pyplumio-0.5.43 → pyplumio-0.5.49}/PyPlumIO.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ pyplumio/__main__.py
 pyplumio/_version.py
 pyplumio/connection.py
 pyplumio/const.py
+pyplumio/data_types.py
 pyplumio/exceptions.py
 pyplumio/filters.py
 pyplumio/protocol.py
@@ -58,7 +59,7 @@ pyplumio/frames/messages.py
 pyplumio/frames/requests.py
 pyplumio/frames/responses.py
 pyplumio/helpers/__init__.py
-pyplumio/helpers/data_types.py
+pyplumio/helpers/async_cache.py
 pyplumio/helpers/event_manager.py
 pyplumio/helpers/factory.py
 pyplumio/helpers/schedule.py
@@ -69,6 +70,8 @@ pyplumio/parameters/__init__.py
 pyplumio/parameters/ecomax.py
 pyplumio/parameters/mixer.py
 pyplumio/parameters/thermostat.py
+pyplumio/parameters/custom/__init__.py
+pyplumio/parameters/custom/ecomax_860d3_hb.py
 pyplumio/structures/__init__.py
 pyplumio/structures/alerts.py
 pyplumio/structures/boiler_load.py
@@ -99,19 +102,25 @@ tests/__init__.py
 tests/conftest.py
 tests/ruff.toml
 tests/test_connection.py
-tests/test_devices.py
+tests/test_data_types.py
 tests/test_filters.py
 tests/test_init.py
 tests/test_main.py
 tests/test_protocol.py
 tests/test_stream.py
 tests/test_utils.py
+tests/devices/__init__.py
+tests/devices/test_ecomax.py
+tests/devices/test_ecoster.py
+tests/devices/test_init.py
+tests/devices/test_mixer.py
+tests/devices/test_thermostat.py
 tests/frames/test_init.py
 tests/frames/test_messages.py
 tests/frames/test_requests.py
 tests/frames/test_responses.py
 tests/helpers/__init__.py
-tests/helpers/test_data_types.py
+tests/helpers/test_async_cache.py
 tests/helpers/test_event_manager.py
 tests/helpers/test_factory.py
 tests/helpers/test_schedule.py
@@ -123,8 +132,12 @@ tests/parameters/test_ecomax.py
 tests/parameters/test_init.py
 tests/parameters/test_mixers.py
 tests/parameters/test_thermostats.py
+tests/parameters/custom/__init__.py
+tests/parameters/custom/test_ecomax_860d3_hb.py
+tests/parameters/custom/test_init.py
 tests/testdata/messages/regulator_data.json
 tests/testdata/messages/sensor_data.json
+tests/testdata/parameters/ecomax_860d3_hb.json
 tests/testdata/requests/alerts.json
 tests/testdata/requests/ecomax_control.json
 tests/testdata/requests/ecomax_parameters.json

{pyplumio-0.5.43 → pyplumio-0.5.49}/PyPlumIO.egg-info/requires.txt

@@ -15,10 +15,12 @@ readthedocs-sphinx-search==0.3.2
 [test]
 codespell==2.4.1
 coverage==7.8.0
+freezegun==1.5.1
 mypy==1.15.0
+numpy<3.0.0,>=2.0.0
 pyserial-asyncio-fast==0.16
 pytest==8.3.5
 pytest-asyncio==0.26.0
-ruff==0.11.7
+ruff==0.11.9
 tox==4.25.0
 types-pyserial==3.5.0.20250326

{pyplumio-0.5.43 → pyplumio-0.5.49}/docs/source/callbacks.rst

@@ -38,15 +38,18 @@ All built-in filters are described below.
 
 .. autofunction:: pyplumio.filters.aggregate
 
-This filter aggregates value for specified amount of seconds and 
-then calls the callback with the sum of values collected.
+This filter aggregates values for specified amount of seconds or until
+certain sample size is reached and then calls the callback with the
+sum of values collected.
 
 .. code-block:: python
 
     from pyplumio import filters
 
     # Await the callback with the fuel burned during 30 seconds.
-    ecomax.subscribe("fuel_burned", filters.aggregate(my_callback, seconds=30))
+    ecomax.subscribe(
+        "fuel_burned", filters.aggregate(my_callback, seconds=30, sample_size=100)
+    )
 
 .. autofunction:: pyplumio.filters.clamp
 
@@ -76,6 +79,20 @@ value is changed.
     # last call.
     ecomax.subscribe("heating_temp", filters.on_change(my_callback))
 
+.. autofunction:: pyplumio.filters.deadband
+
+This filter await the callback on signifacant changes only.
+Significance is defined by ``tolerance`` argument (i. e. tolerance=0.1
+will only await callback when value is changed by more that 0.1).
+
+.. code-block:: python
+
+    from pyplumio import filters
+
+    # Await the callback once heating_temp value is changed by more
+    # than 0.1 since last call.
+    ecomax.subscribe("heating_temp", filters.deadband(my_callback, tolerance=0.1))
+
 .. autofunction:: pyplumio.filters.debounce
 
 This filter will only await the callback once value is settled across

{pyplumio-0.5.43 → pyplumio-0.5.49}/docs/source/frames.rst

@@ -436,7 +436,7 @@ Get the regulator data schema, that describes the data type of :ref:`regulatorda
 It's represented by dictionary, that's indexed by regulator data field id and
 a member of the following DataType class, that defines the regulator data field type.
 
-.. autoclass:: pyplumio.helpers.data_types.DataType
+.. autoclass:: pyplumio.data_types.DataType
 
 Request
 ^^^^^^^

{pyplumio-0.5.43 → pyplumio-0.5.49}/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.49'
+__version_tuple__ = version_tuple = (0, 5, 49)

{pyplumio-0.5.43 → pyplumio-0.5.49}/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-0.5.43 → pyplumio-0.5.49}/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
 
@@ -40,7 +39,11 @@ def get_device_handler(device_type: int) -> str:
 
     type_name = to_camelcase(
         DeviceType(device_type).name,
-        overrides={"ecomax": "EcoMAX", "ecoster": "EcoSTER"},
+        overrides={
+            "ecomax": "EcoMAX",
+            "ecoster": "EcoSTER",
+            "econet": "EcoNET",
+        },
     )
     return f"devices.{type_name.lower()}.{type_name}"
 
@@ -69,7 +72,7 @@ class Device(ABC, EventManager):
         :param name: Name of the parameter
         :type name: str
         :param value: New value for the parameter
-        :type value: int | float | bool | Literal["off", "on"]
+        :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
             times, defaults to 5
         :type retries: int, optional
@@ -101,7 +104,7 @@ class Device(ABC, EventManager):
         :param name: Name of the parameter
         :type name: str
         :param value: New value for the parameter
-        :type value: int | float | bool | Literal["off", "on"]
+        :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
             times, defaults to 5
         :type retries: int, optional
@@ -126,11 +129,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 +142,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 frame 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 +181,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 +188,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-0.5.43 → pyplumio-0.5.49}/pyplumio/devices/ecomax.py

@@ -3,15 +3,16 @@
 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,
+    ATTR_SETUP,
     STATE_OFF,
     STATE_ON,
     DeviceState,
@@ -22,6 +23,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 +42,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 +55,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 +136,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 +189,14 @@ 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."""
+        setup_done = self.get_nowait(ATTR_SETUP, False)
+        if setup_done or 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,16 +231,39 @@ 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)
+        parameter_types = await get_ecomax_parameter_types(product_info)
 
-        def _ecomax_parameter_events() -> Generator[Coroutine, Any, None]:
+        def _ecomax_parameter_events() -> Generator[Coroutine]:
             """Get dispatch calls for ecoMAX parameter events."""
-            parameter_types = get_ecomax_parameter_types(product_info)
             for index, values in parameters:
                 try:
                     description = parameter_types[index]
@@ -236,37 +294,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 +319,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 +336,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 +361,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 +390,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 +402,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 +422,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 +443,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(