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

pyplumio/devices/ecomax.py

@@ -3,45 +3,50 @@
 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,
     DeviceType,
     FrameType,
+    State,
 )
 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.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
 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,
@@ -49,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",)
 
-SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
+    _last_update_time: float
+
+    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,
@@ -97,37 +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."""
 
-    address = DeviceType.ECOMAX
-    _setup_frames = SETUP_FRAME_TYPES
+    __slots__ = ("_fuel_meter",)
 
-    _fuel_burned_time_ns: int
+    _fuel_meter: FuelMeter
+
+    address = DeviceType.ECOMAX
 
     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:
-        """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."""
@@ -165,21 +188,83 @@ class EcoMAX(PhysicalDevice):
 
         return self.dispatch_nowait(ATTR_THERMOSTATS, thermostats)
 
-    async def _handle_ecomax_parameters(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
-    ) -> bool:
-        """Handle ecoMAX parameters.
+    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)
 
-        For each parameter dispatch an event with the parameter's name
-        and value.
-        """
-        product: ProductInfo = await self.get(ATTR_PRODUCT)
+    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
+    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: 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]:
             """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 +273,7 @@ class EcoMAX(PhysicalDevice):
                         "and open a feature request to support %s",
                         index,
                         values,
-                        product.model,
+                        product_info.model,
                     )
                     return
 
@@ -207,40 +292,20 @@ 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
+    async def on_event_fuel_consumption(self, fuel_consumption: float) -> None:
+        """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)
 
-        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,
-        )
-
-    async def _handle_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.
-
-        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."""
+        _LOGGER.info("Received mixer parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -252,15 +317,12 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    async def _handle_mixer_sensors(
+    @event_listener
+    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."""
+        _LOGGER.info("Received mixer sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -272,29 +334,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(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
+    @event_listener
+    async def on_event_schedule_parameters(
+        self, parameters: list[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 +359,22 @@ 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
+    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
 
-    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
+    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.
-
-        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."""
+        _LOGGER.info("Received thermostat parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -362,10 +388,11 @@ class EcoMAX(PhysicalDevice):
 
         return False
 
-    async def _add_thermostat_profile_parameter(
+    @event_listener
+    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 +400,12 @@ class EcoMAX(PhysicalDevice):
 
         return None
 
-    async def _handle_thermostat_sensors(
+    @event_listener
+    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."""
+        _LOGGER.info("Received thermostat sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -396,36 +420,40 @@ 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
+    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],
+                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(filter=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

@@ -3,65 +3,52 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Coroutine, Generator, Sequence
+from collections.abc import Coroutine, Generator
 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_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
+    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
 
-    async def _handle_mixer_parameters(
-        self, parameters: Sequence[tuple[int, ParameterValues]]
+    @event_listener
+    async def on_event_mixer_parameters(
+        self, parameters: list[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."""
+        _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]:
             """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"]