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

pyplumio/__init__.py

@@ -13,6 +13,7 @@ from pyplumio.exceptions import (
     ProtocolError,
     PyPlumIOError,
     ReadError,
+    RequestError,
     UnknownDeviceError,
     UnknownFrameError,
 )
@@ -90,6 +91,8 @@ def open_tcp_connection(
 
 
 __all__ = [
+    "__version__",
+    "__version_tuple__",
     "AsyncProtocol",
     "ChecksumError",
     "ConnectionFailedError",
@@ -107,8 +110,6 @@ __all__ = [
     "UnknownDeviceError",
     "UnknownFrameError",
     "WirelessParameters",
-    "__version__",
-    "__version_tuple__",
     "open_serial_connection",
     "open_tcp_connection",
 ]

pyplumio/_version.py

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

pyplumio/connection.py

@@ -5,9 +5,9 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import asyncio
 import logging
-from typing import Any, Final, cast
+from typing import Any, Final
 
-from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE, SerialException
+from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE
 
 from pyplumio.exceptions import ConnectionFailedError
 from pyplumio.helpers.task_manager import TaskManager
@@ -24,7 +24,7 @@ try:
 
     _LOGGER.info("Using pyserial-asyncio-fast in place of pyserial-asyncio")
 except ImportError:
-    import serial_asyncio as pyserial_asyncio
+    import serial_asyncio as pyserial_asyncio  # type: ignore[no-redef]
 
 
 class Connection(ABC, TaskManager):
@@ -73,7 +73,7 @@ class Connection(ABC, TaskManager):
         try:
             reader, writer = await self._open_connection()
             self.protocol.connection_established(reader, writer)
-        except (OSError, SerialException, asyncio.TimeoutError) as err:
+        except (OSError, asyncio.TimeoutError) as err:
             raise ConnectionFailedError from err
 
     async def _reconnect(self) -> None:
@@ -184,14 +184,14 @@ class SerialConnection(Connection):
         self,
     ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
         """Open the connection and return reader and writer objects."""
-        return cast(
-            tuple[asyncio.StreamReader, asyncio.StreamWriter],
-            await pyserial_asyncio.open_serial_connection(
-                url=self.device,
-                baudrate=self.baudrate,
-                bytesize=EIGHTBITS,
-                parity=PARITY_NONE,
-                stopbits=STOPBITS_ONE,
-                **self._kwargs,
-            ),
+        return await pyserial_asyncio.open_serial_connection(
+            url=self.device,
+            baudrate=self.baudrate,
+            bytesize=EIGHTBITS,
+            parity=PARITY_NONE,
+            stopbits=STOPBITS_ONE,
+            **self._kwargs,
         )
+
+
+__all__ = ["Connection", "TcpConnection", "SerialConnection"]

pyplumio/const.py

@@ -91,6 +91,13 @@ class ProductType(IntEnum):
     ECOMAX_I = 1
 
 
+@unique
+class ProductModel(Enum):
+    """Contains device models."""
+
+    ECOMAX_860D3_HB = "ecoMAX 860D3-HB"
+
+
 @unique
 class AlertType(IntEnum):
     """Contains alert types."""

pyplumio/devices/__init__.py

@@ -8,12 +8,13 @@ from functools import cache
 import logging
 from typing import Any, ClassVar
 
-from pyplumio.const import ATTR_FRAME_ERRORS, ATTR_LOADED, DeviceType, FrameType
+from pyplumio.const import ATTR_FRAME_ERRORS, ATTR_LOADED, 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.helpers.event_manager import EventManager
+from pyplumio.helpers.event_manager import EventManager, event_listener
 from pyplumio.helpers.factory import create_instance
-from pyplumio.helpers.parameter import NumericType, Parameter, State
+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
@@ -47,6 +48,8 @@ def get_device_handler(device_type: int) -> str:
 class Device(ABC, EventManager):
     """Represents a device."""
 
+    __slots__ = ("queue",)
+
     queue: asyncio.Queue[Frame]
 
     def __init__(self, queue: asyncio.Queue[Frame]) -> None:
@@ -123,6 +126,8 @@ class PhysicalDevice(Device, ABC):
     virtual devices associated with them via parent property.
     """
 
+    __slots__ = ("address", "_network", "_setup_frames", "_frame_versions")
+
     address: ClassVar[int]
     _network: NetworkInfo
     _setup_frames: tuple[DataFrameDescription, ...]
@@ -134,22 +139,19 @@ class PhysicalDevice(Device, ABC):
         self._network = network
         self._frame_versions = {}
 
-        async def update_frame_versions(versions: dict[int, int]) -> None:
-            """Check frame versions and update outdated frames."""
-            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)
-                    self._frame_versions[frame_type] = version
-
-        self.subscribe(ATTR_FRAME_VERSIONS, update_frame_versions)
+    @event_listener(ATTR_FRAME_VERSIONS, on_change)
+    async def on_event_frame_versions(self, versions: dict[int, int]) -> None:
+        """Check frame versions and update outdated frames."""
+        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)
+                self._frame_versions[frame_type] = version
 
     def has_frame_version(self, frame_type: FrameType | int, version: int) -> bool:
         """Return True if frame data is up to date, False otherwise."""
@@ -218,6 +220,8 @@ class PhysicalDevice(Device, ABC):
 class VirtualDevice(Device, ABC):
     """Represents a virtual device associated with physical device."""
 
+    __slots__ = ("parent", "index")
+
     parent: PhysicalDevice
     index: int
 
@@ -228,3 +232,12 @@ class VirtualDevice(Device, ABC):
         super().__init__(queue)
         self.parent = parent
         self.index = index
+
+
+__all__ = [
+    "Device",
+    "PhysicalDevice",
+    "VirtualDevice",
+    "is_known_device_type",
+    "get_device_handler",
+]

pyplumio/devices/ecomax.py

@@ -12,27 +12,33 @@ from pyplumio.const import (
     ATTR_PASSWORD,
     ATTR_SENSORS,
     ATTR_STATE,
+    STATE_OFF,
+    STATE_ON,
     DeviceState,
     DeviceType,
     FrameType,
+    State,
 )
 from pyplumio.devices import PhysicalDevice
 from pyplumio.devices.mixer import Mixer
 from pyplumio.devices.thermostat import Thermostat
 from pyplumio.filters import on_change
 from pyplumio.frames import DataFrameDescription, Frame, Request
-from pyplumio.helpers.parameter import STATE_OFF, STATE_ON, ParameterValues, State
+from pyplumio.helpers.event_manager import event_listener
 from pyplumio.helpers.schedule import Schedule, ScheduleDay
-from pyplumio.structures.alerts import ATTR_TOTAL_ALERTS
-from pyplumio.structures.ecomax_parameters import (
-    ATTR_ECOMAX_CONTROL,
-    ATTR_ECOMAX_PARAMETERS,
+from pyplumio.parameters import ParameterValues
+from pyplumio.parameters.ecomax import (
     ECOMAX_CONTROL_PARAMETER,
-    ECOMAX_PARAMETERS,
     THERMOSTAT_PROFILE_PARAMETER,
     EcomaxNumber,
     EcomaxSwitch,
     EcomaxSwitchDescription,
+    get_ecomax_parameter_types,
+)
+from pyplumio.structures.alerts import ATTR_TOTAL_ALERTS
+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
@@ -103,6 +109,8 @@ _LOGGER = logging.getLogger(__name__)
 class EcoMAX(PhysicalDevice):
     """Represents an ecoMAX controller."""
 
+    __slots__ = ("_fuel_burned_time_ns",)
+
     address = DeviceType.ECOMAX
     _setup_frames = SETUP_FRAME_TYPES
 
@@ -111,17 +119,6 @@ class EcoMAX(PhysicalDevice):
     def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
         """Initialize a new ecoMAX controller."""
         super().__init__(queue, network)
-        self.subscribe(ATTR_ECOMAX_PARAMETERS, self._handle_ecomax_parameters)
-        self.subscribe(ATTR_FUEL_CONSUMPTION, self._add_burned_fuel_meter)
-        self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_mixer_parameters)
-        self.subscribe(ATTR_MIXER_SENSORS, self._handle_mixer_sensors)
-        self.subscribe(ATTR_SCHEDULES, self._add_schedules)
-        self.subscribe(ATTR_SCHEDULE_PARAMETERS, self._add_schedule_parameters)
-        self.subscribe(ATTR_SENSORS, self._handle_ecomax_sensors)
-        self.subscribe(ATTR_STATE, on_change(self._add_ecomax_control_parameter))
-        self.subscribe(ATTR_THERMOSTAT_PARAMETERS, self._handle_thermostat_parameters)
-        self.subscribe(ATTR_THERMOSTAT_PROFILE, self._add_thermostat_profile_parameter)
-        self.subscribe(ATTR_THERMOSTAT_SENSORS, self._handle_thermostat_sensors)
         self._fuel_burned_time_ns = time.perf_counter_ns()
 
     async def async_setup(self) -> bool:
@@ -165,21 +162,53 @@ class EcoMAX(PhysicalDevice):
 
         return self.dispatch_nowait(ATTR_THERMOSTATS, thermostats)
 
-    async def _handle_ecomax_parameters(
+    async def _set_ecomax_state(self, state: State) -> bool:
+        """Try to set the ecoMAX control state."""
+        try:
+            switch: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
+            return await switch.set(state)
+        except KeyError:
+            _LOGGER.error("ecoMAX control is not available. Please try again later.")
+
+        return False
+
+    async def turn_on(self) -> bool:
+        """Turn on the ecoMAX controller."""
+        return await self._set_ecomax_state(STATE_ON)
+
+    async def turn_off(self) -> bool:
+        """Turn off the ecoMAX controller."""
+        return await self._set_ecomax_state(STATE_OFF)
+
+    def turn_on_nowait(self) -> None:
+        """Turn on the ecoMAX controller without waiting."""
+        self.create_task(self.turn_on())
+
+    def turn_off_nowait(self) -> None:
+        """Turn off the ecoMAX controller without waiting."""
+        self.create_task(self.turn_off())
+
+    async def shutdown(self) -> None:
+        """Shutdown tasks for the ecoMAX controller and sub-devices."""
+        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()
+
+    @event_listener(ATTR_ECOMAX_PARAMETERS)
+    async def on_event_ecomax_parameters(
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
-        """Handle ecoMAX parameters.
-
-        For each parameter dispatch an event with the parameter's name
-        and value.
-        """
-        product: ProductInfo = await self.get(ATTR_PRODUCT)
+        """Update ecoMAX parameters and dispatch the events."""
+        product_info: ProductInfo = await self.get(ATTR_PRODUCT)
 
         def _ecomax_parameter_events() -> Generator[Coroutine, Any, None]:
             """Get dispatch calls for ecoMAX parameter events."""
+            parameter_types = get_ecomax_parameter_types(product_info)
             for index, values in parameters:
                 try:
-                    description = ECOMAX_PARAMETERS[product.type][index]
+                    description = parameter_types[index]
                 except IndexError:
                     _LOGGER.warning(
                         "Encountered unknown ecoMAX parameter (%i): %s. "
@@ -188,7 +217,7 @@ class EcoMAX(PhysicalDevice):
                         "and open a feature request to support %s",
                         index,
                         values,
-                        product.model,
+                        product_info.model,
                     )
                     return
 
@@ -207,8 +236,9 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*_ecomax_parameter_events())
         return True
 
-    async def _add_burned_fuel_meter(self, fuel_consumption: float) -> None:
-        """Calculate and dispatch the amount of fuel burned.
+    @event_listener(ATTR_FUEL_CONSUMPTION)
+    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
@@ -231,16 +261,12 @@ class EcoMAX(PhysicalDevice):
             nanoseconds_passed / NANOSECONDS_IN_SECOND,
         )
 
-    async def _handle_mixer_parameters(
+    @event_listener(ATTR_MIXER_PARAMETERS)
+    async def on_event_mixer_parameters(
         self,
         parameters: dict[int, Sequence[tuple[int, ParameterValues]]] | None,
     ) -> bool:
-        """Handle mixer parameters.
-
-        For each parameter dispatch an event with the
-        parameter's name and value. Events are dispatched for the
-        respective mixer instance.
-        """
+        """Handle mixer parameters and dispatch the events."""
         if parameters:
             await asyncio.gather(
                 *(
@@ -252,15 +278,11 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    async def _handle_mixer_sensors(
+    @event_listener(ATTR_MIXER_SENSORS)
+    async def on_event_mixer_sensors(
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
-        """Handle mixer sensors.
-
-        For each sensor dispatch an event with the
-        sensor's name and value. Events are dispatched for the
-        respective mixer instance.
-        """
+        """Update mixer sensors and dispatch the events."""
         if sensors:
             await asyncio.gather(
                 *(
@@ -272,29 +294,11 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    async def _add_schedules(
-        self, schedules: list[tuple[int, list[list[bool]]]]
-    ) -> dict[str, Schedule]:
-        """Add schedules to the dataset."""
-        return {
-            SCHEDULES[index]: Schedule(
-                name=SCHEDULES[index],
-                device=self,
-                monday=ScheduleDay.from_iterable(schedule[1]),
-                tuesday=ScheduleDay.from_iterable(schedule[2]),
-                wednesday=ScheduleDay.from_iterable(schedule[3]),
-                thursday=ScheduleDay.from_iterable(schedule[4]),
-                friday=ScheduleDay.from_iterable(schedule[5]),
-                saturday=ScheduleDay.from_iterable(schedule[6]),
-                sunday=ScheduleDay.from_iterable(schedule[0]),
-            )
-            for index, schedule in schedules
-        }
-
-    async def _add_schedule_parameters(
+    @event_listener(ATTR_SCHEDULE_PARAMETERS)
+    async def on_event_schedule_parameters(
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
-        """Add schedule parameters to the dataset."""
+        """Update schedule parameters and dispatch the events."""
 
         def _schedule_parameter_events() -> Generator[Coroutine, Any, None]:
             """Get dispatch calls for schedule parameter events."""
@@ -315,40 +319,20 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*_schedule_parameter_events())
         return True
 
-    async def _handle_ecomax_sensors(self, sensors: dict[str, Any]) -> bool:
-        """Handle ecoMAX sensors.
-
-        For each sensor dispatch an event with the sensor's name and
-        value.
-        """
+    @event_listener(ATTR_SENSORS)
+    async def on_event_sensors(self, sensors: dict[str, Any]) -> bool:
+        """Update ecoMAX sensors and dispatch the events."""
         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."""
-        await self.dispatch(
-            ECOMAX_CONTROL_PARAMETER.name,
-            EcomaxSwitch.create_or_update(
-                description=ECOMAX_CONTROL_PARAMETER,
-                device=self,
-                values=ParameterValues(
-                    value=int(mode != DeviceState.OFF), min_value=0, max_value=1
-                ),
-            ),
-        )
-
-    async def _handle_thermostat_parameters(
+    @event_listener(ATTR_THERMOSTAT_PARAMETERS)
+    async def on_event_thermostat_parameters(
         self,
         parameters: dict[int, Sequence[tuple[int, ParameterValues]]] | None,
     ) -> bool:
-        """Handle thermostat parameters.
-
-        For each parameter dispatch an event with the
-        parameter's name and value. Events are dispatched for the
-        respective thermostat instance.
-        """
+        """Handle thermostat parameters and dispatch the events."""
         if parameters:
             await asyncio.gather(
                 *(
@@ -362,10 +346,11 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    async def _add_thermostat_profile_parameter(
+    @event_listener(ATTR_THERMOSTAT_PROFILE)
+    async def on_event_thermostat_profile(
         self, values: ParameterValues | None
     ) -> EcomaxNumber | None:
-        """Add thermostat profile parameter to the dataset."""
+        """Update thermostat profile parameter."""
         if values:
             return EcomaxNumber(
                 device=self, description=THERMOSTAT_PROFILE_PARAMETER, values=values
@@ -373,15 +358,11 @@ class EcoMAX(PhysicalDevice):
 
         return None
 
-    async def _handle_thermostat_sensors(
+    @event_listener(ATTR_THERMOSTAT_SENSORS)
+    async def on_event_thermostat_sensors(
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
-        """Handle thermostat sensors.
-
-        For each sensor dispatch an event with the
-        sensor's name and value. Events are dispatched for the
-        respective thermostat instance.
-        """
+        """Update thermostat sensors and dispatch the events."""
         if sensors:
             await asyncio.gather(
                 *(
@@ -396,36 +377,39 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    async def _set_ecomax_state(self, state: State) -> bool:
-        """Try to set the ecoMAX control state."""
-        try:
-            switch: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
-            return await switch.set(state)
-        except KeyError:
-            _LOGGER.error("ecoMAX control is not available. Please try again later.")
-
-        return False
-
-    async def turn_on(self) -> bool:
-        """Turn on the ecoMAX controller."""
-        return await self._set_ecomax_state(STATE_ON)
-
-    async def turn_off(self) -> bool:
-        """Turn off the ecoMAX controller."""
-        return await self._set_ecomax_state(STATE_OFF)
+    @event_listener(ATTR_SCHEDULES)
+    async def on_event_schedules(
+        self, schedules: list[tuple[int, list[list[bool]]]]
+    ) -> dict[str, Schedule]:
+        """Update schedules."""
+        return {
+            SCHEDULES[index]: Schedule(
+                name=SCHEDULES[index],
+                device=self,
+                monday=ScheduleDay.from_iterable(schedule[1]),
+                tuesday=ScheduleDay.from_iterable(schedule[2]),
+                wednesday=ScheduleDay.from_iterable(schedule[3]),
+                thursday=ScheduleDay.from_iterable(schedule[4]),
+                friday=ScheduleDay.from_iterable(schedule[5]),
+                saturday=ScheduleDay.from_iterable(schedule[6]),
+                sunday=ScheduleDay.from_iterable(schedule[0]),
+            )
+            for index, schedule in schedules
+        }
 
-    def turn_on_nowait(self) -> None:
-        """Turn on the ecoMAX controller without waiting."""
-        self.create_task(self.turn_on())
+    @event_listener(ATTR_STATE, on_change)
+    async def on_event_state(self, state: DeviceState) -> None:
+        """Update the ecoMAX control parameter."""
+        await self.dispatch(
+            ECOMAX_CONTROL_PARAMETER.name,
+            EcomaxSwitch.create_or_update(
+                description=ECOMAX_CONTROL_PARAMETER,
+                device=self,
+                values=ParameterValues(
+                    value=int(state != DeviceState.OFF), min_value=0, max_value=1
+                ),
+            ),
+        )
 
-    def turn_off_nowait(self) -> None:
-        """Turn off the ecoMAX controller without waiting."""
-        self.create_task(self.turn_off())
 
-    async def shutdown(self) -> None:
-        """Shutdown tasks for the ecoMAX controller and sub-devices."""
-        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()
+__all__ = ["ATTR_MIXERS", "ATTR_THERMOSTATS", "ATTR_FUEL_BURNED", "EcoMAX"]

pyplumio/devices/ecoster.py

@@ -9,4 +9,9 @@ from pyplumio.devices import PhysicalDevice
 class EcoSTER(PhysicalDevice):
     """Represents an ecoSTER thermostat."""
 
+    __slots__ = ()
+
     address = DeviceType.ECOSTER
+
+
+__all__ = ["EcoSTER"]

pyplumio/devices/mixer.py

@@ -5,63 +5,50 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Coroutine, Generator, Sequence
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
-from pyplumio.devices import PhysicalDevice, VirtualDevice
-from pyplumio.helpers.parameter import ParameterValues
-from pyplumio.structures.mixer_parameters import (
-    ATTR_MIXER_PARAMETERS,
-    MIXER_PARAMETERS,
+from pyplumio.devices import VirtualDevice
+from pyplumio.helpers.event_manager import event_listener
+from pyplumio.parameters import ParameterValues
+from pyplumio.parameters.mixer import (
     MixerNumber,
     MixerSwitch,
     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
 
-if TYPE_CHECKING:
-    from pyplumio.frames import Frame
-
 _LOGGER = logging.getLogger(__name__)
 
 
 class Mixer(VirtualDevice):
     """Represents a mixer."""
 
-    def __init__(
-        self, queue: asyncio.Queue[Frame], parent: PhysicalDevice, index: int = 0
-    ) -> None:
-        """Initialize a new mixer."""
-        super().__init__(queue, parent, index)
-        self.subscribe(ATTR_MIXER_SENSORS, self._handle_mixer_sensors)
-        self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_mixer_parameters)
-
-    async def _handle_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
-        """Handle mixer sensors.
+    __slots__ = ()
 
-        For each sensor dispatch an event with the
-        sensor's name and value.
-        """
+    @event_listener(ATTR_MIXER_SENSORS)
+    async def on_event_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
+        """Update mixer sensors and dispatch the events."""
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
         return True
 
-    async def _handle_mixer_parameters(
+    @event_listener(ATTR_MIXER_PARAMETERS)
+    async def on_event_mixer_parameters(
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
-        """Handle mixer parameters.
-
-        For each parameter dispatch an event with the
-        parameter's name and value.
-        """
-        product: ProductInfo = await self.parent.get(ATTR_PRODUCT)
+        """Update mixer parameters and dispatch the events."""
+        product_info: ProductInfo = await self.parent.get(ATTR_PRODUCT)
 
         def _mixer_parameter_events() -> Generator[Coroutine, Any, None]:
             """Get dispatch calls for mixer parameter events."""
+            parameter_types = get_mixer_parameter_types(product_info)
             for index, values in parameters:
                 try:
-                    description = MIXER_PARAMETERS[product.type][index]
+                    description = parameter_types[index]
                 except IndexError:
                     _LOGGER.warning(
                         "Encountered unknown mixer parameter (%i): %s. "
@@ -70,7 +57,7 @@ class Mixer(VirtualDevice):
                         "and open a feature request to support %s",
                         index,
                         values,
-                        product.model,
+                        product_info.model,
                     )
                     return
 
@@ -88,3 +75,6 @@ class Mixer(VirtualDevice):
 
         await asyncio.gather(*_mixer_parameter_events())
         return True
+
+
+__all__ = ["Mixer"]