PyPlumIO 0.5.21__py3-none-any.whl → 0.5.23__py3-none-any.whl

pyplumio/devices/ecomax.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Generator, Iterable, Sequence
+from collections.abc import Coroutine, Generator, Iterable, Sequence
 import logging
 import time
 from typing import Any, ClassVar, Final
@@ -17,7 +17,7 @@ from pyplumio.const import (
     DeviceType,
     FrameType,
 )
-from pyplumio.devices import AddressableDevice, SubDevice
+from pyplumio.devices import AddressableDevice
 from pyplumio.devices.mixer import Mixer
 from pyplumio.devices.thermostat import Thermostat
 from pyplumio.filters import on_change
@@ -31,9 +31,9 @@ from pyplumio.structures.ecomax_parameters import (
     ECOMAX_CONTROL_PARAMETER,
     ECOMAX_PARAMETERS,
     THERMOSTAT_PROFILE_PARAMETER,
-    EcomaxBinaryParameter,
-    EcomaxBinaryParameterDescription,
-    EcomaxParameter,
+    EcomaxNumber,
+    EcomaxSwitch,
+    EcomaxSwitchDescription,
 )
 from pyplumio.structures.frame_versions import ATTR_FRAME_VERSIONS
 from pyplumio.structures.fuel_consumption import ATTR_FUEL_CONSUMPTION
@@ -47,9 +47,9 @@ from pyplumio.structures.schedules import (
     ATTR_SCHEDULES,
     SCHEDULE_PARAMETERS,
     SCHEDULES,
-    ScheduleBinaryParameter,
-    ScheduleBinaryParameterDescription,
-    ScheduleParameter,
+    ScheduleNumber,
+    ScheduleSwitch,
+    ScheduleSwitchDescription,
 )
 from pyplumio.structures.thermostat_parameters import (
     ATTR_THERMOSTAT_PARAMETERS,
@@ -64,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__)
@@ -94,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 = {}
@@ -123,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)
 
@@ -148,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)
 
@@ -164,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)
 
@@ -182,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 = (
+                    EcomaxSwitch
+                    if isinstance(description, EcomaxSwitchDescription)
+                    else EcomaxNumber
+                )
+                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:
@@ -236,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,15 +267,17 @@ class EcoMAX(AddressableDevice):
             return False
 
         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
@@ -282,10 +288,10 @@ class EcoMAX(AddressableDevice):
             return False
 
         await asyncio.gather(
-            *[
+            *(
                 mixer.dispatch(ATTR_MIXER_SENSORS, sensors[mixer.index])
                 for mixer in self._mixers(indexes=sensors.keys())
-            ]
+            )
         )
 
         return True
@@ -313,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 = (
+                    ScheduleSwitch
+                    if isinstance(description, ScheduleSwitchDescription)
+                    else ScheduleNumber
+                )
+                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:
@@ -341,28 +349,20 @@ class EcoMAX(AddressableDevice):
         value.
         """
         await asyncio.gather(
-            *[self.dispatch(name, value) for name, value in sensors.items()]
+            *(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,
+            EcomaxSwitch.create_or_update(
+                description=ECOMAX_CONTROL_PARAMETER,
+                device=self,
+                values=ParameterValues(
+                    value=int(mode != DeviceState.OFF), min_value=0, max_value=1
+                ),
             ),
         )
 
@@ -380,29 +380,28 @@ class EcoMAX(AddressableDevice):
             return False
 
         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:
+    ) -> EcomaxNumber | 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 EcomaxNumber(
+            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.
 
@@ -414,10 +413,11 @@ class EcoMAX(AddressableDevice):
             return False
 
         await asyncio.gather(
-            *[
+            *(
                 thermostat.dispatch(ATTR_THERMOSTAT_SENSORS, sensors[thermostat.index])
                 for thermostat in self._thermostats(indexes=sensors.keys())
-            ]
+            ),
+            return_exceptions=True,
         )
 
         return True
@@ -425,7 +425,7 @@ class EcoMAX(AddressableDevice):
     async def turn_on(self) -> bool:
         """Turn on the ecoMAX controller."""
         try:
-            ecomax_control: EcomaxBinaryParameter = self.data[ATTR_ECOMAX_CONTROL]
+            ecomax_control: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
             return await ecomax_control.turn_on()
         except KeyError:
             _LOGGER.error("ecoMAX control isn't available, please try later")
@@ -434,7 +434,7 @@ class EcoMAX(AddressableDevice):
     async def turn_off(self) -> bool:
         """Turn off the ecoMAX controller."""
         try:
-            ecomax_control: EcomaxBinaryParameter = self.data[ATTR_ECOMAX_CONTROL]
+            ecomax_control: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
             return await ecomax_control.turn_off()
         except KeyError:
             _LOGGER.error("ecoMAX control isn't available, please try later")
@@ -450,8 +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, {})
-        devices: Iterable[SubDevice] = (mixers | thermostats).values()
-        await asyncio.gather(*[device.shutdown() for device in 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()

pyplumio/devices/mixer.py

@@ -3,47 +3,51 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Sequence
+from collections.abc import Coroutine, Generator, Sequence
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from pyplumio.devices import AddressableDevice, SubDevice
 from pyplumio.helpers.parameter import ParameterValues
 from pyplumio.structures.mixer_parameters import (
     ATTR_MIXER_PARAMETERS,
     MIXER_PARAMETERS,
-    MixerBinaryParameter,
-    MixerBinaryParameterDescription,
-    MixerParameter,
+    MixerNumber,
+    MixerSwitch,
+    MixerSwitchDescription,
 )
 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(SubDevice):
     """Represents an mixer."""
 
-    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 mixer."""
         super().__init__(queue, parent, index)
-        self.subscribe(ATTR_MIXER_SENSORS, self._handle_sensors)
-        self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_parameters)
+        self.subscribe(ATTR_MIXER_SENSORS, self._handle_mixer_sensors)
+        self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_mixer_parameters)
 
-    async def _handle_sensors(self, sensors: dict[str, Any]) -> bool:
+    async def _handle_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
         """Handle mixer sensors.
 
         For each sensor dispatch an event with the
         sensor's name and value.
         """
         await asyncio.gather(
-            *[self.dispatch(name, value) for name, value in sensors.items()]
+            *(self.dispatch(name, value) for name, value in sensors.items())
         )
-
         return True
 
-    async def _handle_parameters(
+    async def _handle_mixer_parameters(
         self, parameters: Sequence[tuple[int, ParameterValues]]
     ) -> bool:
         """Handle mixer parameters.
@@ -52,39 +56,41 @@ class Mixer(SubDevice):
         parameter's name and value.
         """
         product: ProductInfo = await self.parent.get(ATTR_PRODUCT)
-        for index, values in parameters:
-            try:
-                description = MIXER_PARAMETERS[product.type][index]
-            except IndexError:
-                _LOGGER.warning(
-                    (
-                        "Encountered unknown mixer 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,
-                )
-                return False
 
-            name = description.name
-            if name in self.data:
-                parameter: MixerParameter = self.data[name]
-                parameter.values = values
-                await self.dispatch(name, parameter)
-                continue
+        def _mixer_parameter_events() -> Generator[Coroutine, Any, None]:
+            """Get dispatch calls for mixer parameter events."""
+            for index, values in parameters:
+                try:
+                    description = MIXER_PARAMETERS[product.type][index]
+                except IndexError:
+                    _LOGGER.warning(
+                        (
+                            "Encountered unknown mixer 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,
+                    )
+                    return
 
-            cls = (
-                MixerBinaryParameter
-                if isinstance(description, MixerBinaryParameterDescription)
-                else MixerParameter
-            )
-            await self.dispatch(
-                name,
-                cls(device=self, values=values, description=description, index=index),
-            )
+                handler = (
+                    MixerSwitch
+                    if isinstance(description, MixerSwitchDescription)
+                    else MixerNumber
+                )
+                yield self.dispatch(
+                    description.name,
+                    handler.create_or_update(
+                        device=self,
+                        description=description,
+                        values=values,
+                        index=index,
+                    ),
+                )
 
+        await asyncio.gather(*_mixer_parameter_events())
         return True