PyPlumIO 0.5.35__py3-none-any.whl → 0.5.36__py3-none-any.whl

{PyPlumIO-0.5.35.dist-info → PyPlumIO-0.5.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPlumIO
-Version: 0.5.35
+Version: 0.5.36
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -27,22 +27,22 @@ Requires-Dist: dataslots==1.2.0
 Requires-Dist: pyserial-asyncio==0.6
 Requires-Dist: typing-extensions==4.12.2
 Provides-Extra: test
-Requires-Dist: codespell==2.3.0; extra == "test"
+Requires-Dist: codespell==2.4.0; extra == "test"
 Requires-Dist: coverage==7.6.10; extra == "test"
 Requires-Dist: mypy==1.14.1; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.14; extra == "test"
 Requires-Dist: pytest==8.3.4; extra == "test"
 Requires-Dist: pytest-asyncio==0.25.2; extra == "test"
-Requires-Dist: ruff==0.9.2; extra == "test"
-Requires-Dist: tox==4.23.2; extra == "test"
-Requires-Dist: types-pyserial==3.5.0.20241221; extra == "test"
+Requires-Dist: ruff==0.9.3; extra == "test"
+Requires-Dist: tox==4.24.1; extra == "test"
+Requires-Dist: types-pyserial==3.5.0.20250124; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"
 Requires-Dist: sphinx_rtd_theme==3.0.2; extra == "docs"
 Requires-Dist: readthedocs-sphinx-search==0.3.2; extra == "docs"
 Provides-Extra: dev
 Requires-Dist: pyplumio[docs,test]; extra == "dev"
-Requires-Dist: pre-commit==4.0.1; extra == "dev"
+Requires-Dist: pre-commit==4.1.0; extra == "dev"
 Requires-Dist: tomli==2.2.1; extra == "dev"
 
 # PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.

{PyPlumIO-0.5.35.dist-info → PyPlumIO-0.5.36.dist-info}/RECORD

@@ -1,32 +1,32 @@
-pyplumio/__init__.py,sha256=ditJTIOFGJDg60atHzOpiggdUrZHpSynno7MtpZUGVk,3299
+pyplumio/__init__.py,sha256=3ibJ43RIdfFrWp1PAsQixybAA--NPRw43B5OdLOwsU8,3319
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=J8xgWxzK8uRktLMJfG0M8fVxK4sfrTuU-akVgfoP1wU,413
-pyplumio/connection.py,sha256=6mUbcjGxxEhMVIbzZgCqH-Ez-fcYoRj7ZbVSzpikpNA,5949
+pyplumio/_version.py,sha256=gzGL-qBNqAXMnFJc3Sr0_AdQLS33_rosqhjOurMUizQ,413
+pyplumio/connection.py,sha256=-dbrIK6ewoYNeBQod9ZmXT8JkxMKbcS6nosINFsg9RI,5972
 pyplumio/const.py,sha256=LyXa5aVy2KxnZq7H7F8s5SYsAgEC2UzZYMMRauliB2E,5502
-pyplumio/exceptions.py,sha256=lzZFzq9aszav_pmAbWbN4IfzAAqZe0nE0mRFsscJ3rw,772
+pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
 pyplumio/filters.py,sha256=AMW1zHQ1YjJfHX7e87Dhv7AGixJ3y9Vn-_JAQn7vIsg,12526
 pyplumio/protocol.py,sha256=VRxrj8vZ1FMawqblKkyxg_V61TBSvVynd9u0JXYnMUU,8090
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyplumio/stream.py,sha256=Ne-mWkO6FpILAjGdagbAh_VL3QEla-eDiT2N-kOc5o4,4883
 pyplumio/utils.py,sha256=TnBzRopinyp92wruguijxcIYmaeyNVTFX0dygI5FCMU,823
-pyplumio/devices/__init__.py,sha256=v3EwUf2cGj9Mbxwa6kRMYqUIiREVIbxaVZaR2p5jmaE,8123
-pyplumio/devices/ecomax.py,sha256=LWDIlnC2lIOF2L5obLwpHKY0KTxp81TbrMGAzk7GlSw,15528
+pyplumio/devices/__init__.py,sha256=Erjd3DeEop_yelnLtRRaPbwMIuD1NwVh7dMM1_2KxtI,8155
+pyplumio/devices/ecomax.py,sha256=hb4QULpyg5KrCWeQDNnwy7IA9k5oRETK5AWllVgA0Kg,15806
 pyplumio/devices/ecoster.py,sha256=jNWli7ye9T6yfkcFJZhhUHH7KOv-L6AgYFp_dKyv3OM,263
-pyplumio/devices/mixer.py,sha256=CnHWrJELtFgs2YTHGpQwKr2UTRdetX76OvLBA2PH-fs,3207
+pyplumio/devices/mixer.py,sha256=HdJNsvX3obYyLsuDhERX4IkodX3hGv3veP9ymjQnoUk,3108
 pyplumio/devices/thermostat.py,sha256=-CZNRyywoDU6csFu85KSmQ5woVXY0x6peXkeOsi_fqg,2617
 pyplumio/frames/__init__.py,sha256=30ECFT_5IneUrpOJGxjHyeuX-i4S1ikX8Pg1HO8Yxkg,7686
 pyplumio/frames/messages.py,sha256=iDwZOPdVOZaIcEHYnkwtCazH_N6BjyEDtiJBjTRaePY,3570
-pyplumio/frames/requests.py,sha256=nbSuOLue2rI4WgtXslqTGfFnWBlwzLE6I9wraKC1uqg,6854
-pyplumio/frames/responses.py,sha256=Ch1AVBmD6Ek7BazoEMDDEa6ad_fUdUXf4bNssQOu0sI,6228
+pyplumio/frames/requests.py,sha256=X9P0TdCd8z7pf2XspuontEJsLy00EZfxxue6pg-_MT8,6854
+pyplumio/frames/responses.py,sha256=dzrL0Yx7SoJuJAQyjOE8_ARfy7yvOqk2uq4kdnH5t1U,6228
 pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
 pyplumio/helpers/data_types.py,sha256=nB3afOLmppgSCWkZoX1-1yWPNMMNSem77x7XQ1Mi8H8,9103
 pyplumio/helpers/event_manager.py,sha256=xQOfiP_nP1Pz5zhB6HU5gXyyJXjhisYshL8_HRxDgt8,6412
 pyplumio/helpers/factory.py,sha256=v07s9DyihfkNUzt7ndyJbNd_DLS8UpRkut_xkGrbi6c,1123
-pyplumio/helpers/parameter.py,sha256=lolBkPp69cD1ME8SVQf5VVd_R7nOtrZuhUvKCz1amIg,12390
-pyplumio/helpers/schedule.py,sha256=rlq3O2Xflqks6V1rMoHKy_lww8zJJpuHFFouM2pikJw,5417
+pyplumio/helpers/parameter.py,sha256=ubqgleTPT-m3yxhJkQWoLjkbjCdwOeaNhdA7O66l47Q,12425
+pyplumio/helpers/schedule.py,sha256=0lkghnnpQRdRtgqoNv7PnHMYYJpJNMHl9PR4_SaHB8w,5374
 pyplumio/helpers/task_manager.py,sha256=HAd69yGTRL0zQsu-ywnbLu1UXiJzgHWuhYWA--vs4lQ,1181
 pyplumio/helpers/timeout.py,sha256=JAhWNtIpcXyVILIwHWVy5mYofqbbRDGKLdTUKkQuajs,772
-pyplumio/helpers/uid.py,sha256=J7gN8i8LE0g6tfL66BJbwsQQqzBBxWx7giyvqaJh4BM,976
+pyplumio/helpers/uid.py,sha256=qcE8sx8YwrUX3xEfL0cgjNP65rOZmv-M3fDlgFezUwc,989
 pyplumio/structures/__init__.py,sha256=EjK-5qJZ0F7lpP2b6epvTMg9cIBl4Kn91nqNkEcLwTc,1299
 pyplumio/structures/alerts.py,sha256=8ievMl5_tUBlnTLCiZoIloucIngCcoAYy6uI9sSXrt0,3664
 pyplumio/structures/boiler_load.py,sha256=p3mOzZUU-g7A2tG_yp8podEqpI81hlsOZmHELyPNRY8,838
@@ -53,8 +53,8 @@ pyplumio/structures/statuses.py,sha256=wkoynyMRr1VREwfBC6vU48kPA8ZQ83pcXuciy2xHJ
 pyplumio/structures/temperatures.py,sha256=1CDzehNmbALz1Jyt_9gZNIk52q6Wv-xQXjijVDCVYec,2337
 pyplumio/structures/thermostat_parameters.py,sha256=QA-ZyulBG3P10sqgdI7rmpQYlKm9SJIXxBxAXs8Bwow,8295
 pyplumio/structures/thermostat_sensors.py,sha256=8e1TxYIJTQKT0kIGO9gG4hGdLOBUpIhiPToQyOMyeNE,3237
-PyPlumIO-0.5.35.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-PyPlumIO-0.5.35.dist-info/METADATA,sha256=4QXHmKbKDme-A4wWibnMQdeopxLDsZtKHswzhoChzZ0,5510
-PyPlumIO-0.5.35.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-PyPlumIO-0.5.35.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-PyPlumIO-0.5.35.dist-info/RECORD,,
+PyPlumIO-0.5.36.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+PyPlumIO-0.5.36.dist-info/METADATA,sha256=F7biRxVKU0EPVYWi2uJXZYfVmvwM5j3C_o-O2aoJjQI,5510
+PyPlumIO-0.5.36.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyPlumIO-0.5.36.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.36.dist-info/RECORD,,

pyplumio/__init__.py

@@ -101,6 +101,7 @@ __all__ = [
     "ProtocolError",
     "PyPlumIOError",
     "ReadError",
+    "RequestError",
     "SerialConnection",
     "TcpConnection",
     "UnknownDeviceError",

pyplumio/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.35'
-__version_tuple__ = version_tuple = (0, 5, 35)
+__version__ = version = '0.5.36'
+__version_tuple__ = version_tuple = (0, 5, 36)

pyplumio/connection.py

@@ -86,7 +86,7 @@ class Connection(ABC, TaskManager):
                 RECONNECT_TIMEOUT,
             )
             await asyncio.sleep(RECONNECT_TIMEOUT)
-            self.create_task(self._reconnect())
+            self.create_task(self._reconnect(), name="reconnect_task")
 
     async def connect(self) -> None:
         """Open the connection.

pyplumio/devices/__init__.py

@@ -13,7 +13,7 @@ from pyplumio.exceptions import RequestError, UnknownDeviceError
 from pyplumio.frames import DataFrameDescription, Frame, Request, is_known_frame_type
 from pyplumio.helpers.event_manager import EventManager
 from pyplumio.helpers.factory import create_instance
-from pyplumio.helpers.parameter import Parameter, ParameterValue
+from pyplumio.helpers.parameter import NumericType, Parameter, State
 from pyplumio.structures.frame_versions import ATTR_FRAME_VERSIONS
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.utils import to_camelcase
@@ -57,7 +57,7 @@ class Device(ABC, EventManager):
     async def set(
         self,
         name: str,
-        value: ParameterValue,
+        value: NumericType | State | bool,
         retries: int = 5,
         timeout: float | None = None,
     ) -> bool:
@@ -89,7 +89,7 @@ class Device(ABC, EventManager):
     def set_nowait(
         self,
         name: str,
-        value: ParameterValue,
+        value: NumericType | State | bool,
         retries: int = 5,
         timeout: float | None = None,
     ) -> None:
@@ -180,7 +180,7 @@ class PhysicalDevice(Device, ABC):
         )
 
         errors = [
-            result.args[1] for result in results if isinstance(result, RequestError)
+            result.frame_type for result in results if isinstance(result, RequestError)
         ]
 
         await asyncio.gather(
@@ -204,9 +204,9 @@ class PhysicalDevice(Device, ABC):
                 retries -= 1
 
         raise RequestError(
-            f"Failed to request parameter '{name}' with frame type '{frame_type}' "
-            f"after {retries} retries.",
-            frame_type,
+            f"Failed to request '{name}' with frame type '{frame_type}' after "
+            f"{retries} retries.",
+            frame_type=frame_type,
         )
 
     @classmethod

pyplumio/devices/ecomax.py

@@ -59,7 +59,8 @@ ATTR_MIXERS: Final = "mixers"
 ATTR_THERMOSTATS: Final = "thermostats"
 ATTR_FUEL_BURNED: Final = "fuel_burned"
 
-MAX_TIME_SINCE_LAST_FUEL_UPDATE_NS: Final = 300 * 1000000000
+NANOSECONDS_IN_SECOND: Final = 1_000_000_000
+MAX_TIME_SINCE_LAST_FUEL_UPDATE_NS: Final = 300 * NANOSECONDS_IN_SECOND
 
 SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
     DataFrameDescription(
@@ -105,16 +106,15 @@ class EcoMAX(PhysicalDevice):
     """Represents an ecoMAX controller."""
 
     address = DeviceType.ECOMAX
-
-    _fuel_burned_timestamp_ns: int
     _setup_frames = SETUP_FRAME_TYPES
 
+    _fuel_burned_time_ns: int
+
     def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
         """Initialize a new ecoMAX controller."""
         super().__init__(queue, network)
-        self._fuel_burned_timestamp_ns = time.perf_counter_ns()
         self.subscribe(ATTR_ECOMAX_PARAMETERS, self._handle_ecomax_parameters)
-        self.subscribe(ATTR_FUEL_CONSUMPTION, self._add_burned_fuel_counter)
+        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)
@@ -124,6 +124,7 @@ class EcoMAX(PhysicalDevice):
         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."""
@@ -183,13 +184,10 @@ class EcoMAX(PhysicalDevice):
                     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"
-                        ),
+                        "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,
@@ -211,19 +209,29 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*_ecomax_parameter_events())
         return True
 
-    async def _add_burned_fuel_counter(self, fuel_consumption: float) -> None:
-        """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,
+    async def _add_burned_fuel_meter(self, fuel_consumption: float) -> None:
+        """Calculate and dispatch the amount of 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),
             )
-        else:
-            fuel_burned = fuel_consumption * time_passed_ns / (3600 * 1000000000)
-            await self.dispatch(ATTR_FUEL_BURNED, fuel_burned)
+
+        _LOGGER.warning(
+            "Skipping outdated fuel consumption data: %f (was %i seconds old)",
+            fuel_consumption,
+            nanoseconds_passed / NANOSECONDS_IN_SECOND,
+        )
 
     async def _handle_mixer_parameters(
         self,

pyplumio/devices/mixer.py

@@ -64,13 +64,10 @@ class Mixer(VirtualDevice):
                     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"
-                        ),
+                        "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,

pyplumio/exceptions.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from pyplumio.const import FrameType
+
 
 class PyPlumIOError(Exception):
     """Base PyPlumIO error class."""
@@ -11,13 +13,18 @@ class ConnectionFailedError(PyPlumIOError):
     """Raised on connection failure."""
 
 
-class ProtocolError(PyPlumIOError):
-    """Base class for protocol-related errors."""
-
-
 class RequestError(PyPlumIOError):
     """Raised on request error."""
 
+    def __init__(self, message: str, frame_type: FrameType) -> None:
+        """Initialize a new RequestError."""
+        super().__init__(message)
+        self.frame_type = frame_type
+
+
+class ProtocolError(PyPlumIOError):
+    """Base class for protocol-related errors."""
+
 
 class ReadError(ProtocolError):
     """Raised on read error."""

pyplumio/frames/requests.py

@@ -20,16 +20,20 @@ from pyplumio.frames.responses import DeviceAvailableResponse, ProgramVersionRes
 from pyplumio.structures.schedules import SchedulesStructure
 
 
-class ProgramVersionRequest(Request):
-    """Represents a program version request."""
+class AlertsRequest(Request):
+    """Represents an alerts request.
+
+    Contains number of alerts to get and index of the first
+    alert.
+    """
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_PROGRAM_VERSION
+    frame_type = FrameType.REQUEST_ALERTS
 
-    def response(self, **kwargs: Any) -> Response | None:
-        """Return a response frame."""
-        return ProgramVersionResponse(recipient=self.sender, **kwargs)
+    def create_message(self, data: dict[str, Any]) -> bytearray:
+        """Create a frame message."""
+        return bytearray([data.get(ATTR_START, 0), data.get(ATTR_COUNT, 10)])
 
 
 class CheckDeviceRequest(Request):
@@ -44,20 +48,23 @@ class CheckDeviceRequest(Request):
         return DeviceAvailableResponse(recipient=self.sender, **kwargs)
 
 
-class UIDRequest(Request):
-    """Represents an UID request."""
-
-    __slots__ = ()
-
-    frame_type = FrameType.REQUEST_UID
-
+class EcomaxControlRequest(Request):
+    """Represents an ecoMAX control request.
 
-class PasswordRequest(Request):
-    """Represents a password request."""
+    Contains single binary value. 0 - means that controller should
+    be turned off, 1 - means that it should be turned on.
+    """
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_PASSWORD
+    frame_type = FrameType.REQUEST_ECOMAX_CONTROL
+
+    def create_message(self, data: dict[str, Any]) -> bytearray:
+        """Create a frame message."""
+        try:
+            return bytearray([data[ATTR_VALUE]])
+        except KeyError as e:
+            raise FrameDataError from e
 
 
 class EcomaxParametersRequest(Request):
@@ -91,20 +98,24 @@ class MixerParametersRequest(Request):
         return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_START, 0)])
 
 
-class ThermostatParametersRequest(Request):
-    """Represents a thermostat parameters request.
+class PasswordRequest(Request):
+    """Represents a password request."""
 
-    Contains number of parameters to get and index of the first
-    parameter.
-    """
+    __slots__ = ()
+
+    frame_type = FrameType.REQUEST_PASSWORD
+
+
+class ProgramVersionRequest(Request):
+    """Represents a program version request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_THERMOSTAT_PARAMETERS
+    frame_type = FrameType.REQUEST_PROGRAM_VERSION
 
-    def create_message(self, data: dict[str, Any]) -> bytearray:
-        """Create a frame message."""
-        return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_START, 0)])
+    def response(self, **kwargs: Any) -> Response | None:
+        """Return a response frame."""
+        return ProgramVersionResponse(recipient=self.sender, **kwargs)
 
 
 class RegulatorDataSchemaRequest(Request):
@@ -115,6 +126,14 @@ class RegulatorDataSchemaRequest(Request):
     frame_type = FrameType.REQUEST_REGULATOR_DATA_SCHEMA
 
 
+class SchedulesRequest(Request):
+    """Represents a schedules request."""
+
+    __slots__ = ()
+
+    frame_type = FrameType.REQUEST_SCHEDULES
+
+
 class SetEcomaxParameterRequest(Request):
     """Represents a request to set an ecoMAX parameter.
 
@@ -153,6 +172,18 @@ class SetMixerParameterRequest(Request):
             raise FrameDataError from e
 
 
+class SetScheduleRequest(Request):
+    """Represents a request to set a schedule."""
+
+    __slots__ = ()
+
+    frame_type = FrameType.REQUEST_SET_SCHEDULE
+
+    def create_message(self, data: dict[str, Any]) -> bytearray:
+        """Create a frame message."""
+        return SchedulesStructure(self).encode(data)
+
+
 class SetThermostatParameterRequest(Request):
     """Represents a request to set a thermostat parameter.
 
@@ -183,25 +214,6 @@ class SetThermostatParameterRequest(Request):
             raise FrameDataError from e
 
 
-class EcomaxControlRequest(Request):
-    """Represents an ecoMAX control request.
-
-    Contains single binary value. 0 - means that controller should
-    be turned off, 1 - means that it should be turned on.
-    """
-
-    __slots__ = ()
-
-    frame_type = FrameType.REQUEST_ECOMAX_CONTROL
-
-    def create_message(self, data: dict[str, Any]) -> bytearray:
-        """Create a frame message."""
-        try:
-            return bytearray([data[ATTR_VALUE]])
-        except KeyError as e:
-            raise FrameDataError from e
-
-
 class StartMasterRequest(Request):
     """Represents a request to become a master.
 
@@ -226,37 +238,25 @@ class StopMasterRequest(Request):
     frame_type = FrameType.REQUEST_STOP_MASTER
 
 
-class AlertsRequest(Request):
-    """Represents an alerts request.
+class ThermostatParametersRequest(Request):
+    """Represents a thermostat parameters request.
 
-    Contains number of alerts to get and index of the first
-    alert.
+    Contains number of parameters to get and index of the first
+    parameter.
     """
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_ALERTS
+    frame_type = FrameType.REQUEST_THERMOSTAT_PARAMETERS
 
     def create_message(self, data: dict[str, Any]) -> bytearray:
         """Create a frame message."""
-        return bytearray([data.get(ATTR_START, 0), data.get(ATTR_COUNT, 10)])
-
-
-class SchedulesRequest(Request):
-    """Represents a schedules request."""
-
-    __slots__ = ()
-
-    frame_type = FrameType.REQUEST_SCHEDULES
+        return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_START, 0)])
 
 
-class SetScheduleRequest(Request):
-    """Represents a request to set a schedule."""
+class UIDRequest(Request):
+    """Represents an UID request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.REQUEST_SET_SCHEDULE
-
-    def create_message(self, data: dict[str, Any]) -> bytearray:
-        """Create a frame message."""
-        return SchedulesStructure(self).encode(data)
+    frame_type = FrameType.REQUEST_UID

pyplumio/frames/responses.py

@@ -17,23 +17,16 @@ from pyplumio.structures.schedules import SchedulesStructure
 from pyplumio.structures.thermostat_parameters import ThermostatParametersStructure
 
 
-class ProgramVersionResponse(Response):
-    """Represents a program version response.
-
-    Contains software version info.
-    """
+class AlertsResponse(Response):
+    """Represents response to a device alerts request."""
 
     __slots__ = ()
 
-    frame_type = FrameType.RESPONSE_PROGRAM_VERSION
-
-    def create_message(self, data: dict[str, Any]) -> bytearray:
-        """Create a frame message."""
-        return ProgramVersionStructure(self).encode(data)
+    frame_type = FrameType.RESPONSE_ALERTS
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
-        return ProgramVersionStructure(self).decode(message)[0]
+        return AlertsStructure(self).decode(message)[0]
 
 
 class DeviceAvailableResponse(Response):
@@ -55,39 +48,16 @@ class DeviceAvailableResponse(Response):
         return NetworkInfoStructure(self).decode(message, offset=1)[0]
 
 
-class UIDResponse(Response):
-    """Represents an UID response.
-
-    Contains product info and product UID.
-    """
-
-    __slots__ = ()
-
-    frame_type = FrameType.RESPONSE_UID
-
-    def create_message(self, data: dict[str, Any]) -> bytearray:
-        """Create a frame message."""
-        return ProductInfoStructure(self).encode(data)
-
-    def decode_message(self, message: bytearray) -> dict[str, Any]:
-        """Decode a frame message."""
-        return ProductInfoStructure(self).decode(message)[0]
-
-
-class PasswordResponse(Response):
-    """Represents a password response.
+class EcomaxControlResponse(Response):
+    """Represents response to an ecoMAX control request.
 
-    Contains device service password as plaintext.
+    Empty response acknowledges, that ecoMAX control request was
+    successfully processed.
     """
 
     __slots__ = ()
 
-    frame_type = FrameType.RESPONSE_PASSWORD
-
-    def decode_message(self, message: bytearray) -> dict[str, Any]:
-        """Decode a frame message."""
-        password = message[1:].decode() if message[1:] else None
-        return {ATTR_PASSWORD: password}
+    frame_type = FrameType.RESPONSE_ECOMAX_CONTROL
 
 
 class EcomaxParametersResponse(Response):
@@ -120,19 +90,39 @@ class MixerParametersResponse(Response):
         return MixerParametersStructure(self).decode(message)[0]
 
 
-class ThermostatParametersResponse(Response):
-    """Represents a thermostat parameters response.
+class PasswordResponse(Response):
+    """Represents a password response.
 
-    Contains editable thermostat parameters.
+    Contains device service password as plaintext.
     """
 
     __slots__ = ()
 
-    frame_type = FrameType.RESPONSE_THERMOSTAT_PARAMETERS
+    frame_type = FrameType.RESPONSE_PASSWORD
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
-        return ThermostatParametersStructure(self).decode(message)[0]
+        password = message[1:].decode() if message[1:] else None
+        return {ATTR_PASSWORD: password}
+
+
+class ProgramVersionResponse(Response):
+    """Represents a program version response.
+
+    Contains software version info.
+    """
+
+    __slots__ = ()
+
+    frame_type = FrameType.RESPONSE_PROGRAM_VERSION
+
+    def create_message(self, data: dict[str, Any]) -> bytearray:
+        """Create a frame message."""
+        return ProgramVersionStructure(self).encode(data)
+
+    def decode_message(self, message: bytearray) -> dict[str, Any]:
+        """Decode a frame message."""
+        return ProgramVersionStructure(self).decode(message)[0]
 
 
 class RegulatorDataSchemaResponse(Response):
@@ -151,6 +141,18 @@ class RegulatorDataSchemaResponse(Response):
         return RegulatorDataSchemaStructure(self).decode(message)[0]
 
 
+class SchedulesResponse(Response):
+    """Represents response to a device schedules request."""
+
+    __slots__ = ()
+
+    frame_type = FrameType.RESPONSE_SCHEDULES
+
+    def decode_message(self, message: bytearray) -> dict[str, Any]:
+        """Decode a frame message."""
+        return SchedulesStructure(self).decode(message)[0]
+
+
 class SetEcomaxParameterResponse(Response):
     """Represents response to a set ecoMAX parameter request.
 
@@ -187,37 +189,35 @@ class SetThermostatParameterResponse(Response):
     frame_type = FrameType.RESPONSE_SET_THERMOSTAT_PARAMETER
 
 
-class EcomaxControlResponse(Response):
-    """Represents response to an ecoMAX control request.
+class ThermostatParametersResponse(Response):
+    """Represents a thermostat parameters response.
 
-    Empty response acknowledges, that ecoMAX control request was
-    successfully processed.
+    Contains editable thermostat parameters.
     """
 
     __slots__ = ()
 
-    frame_type = FrameType.RESPONSE_ECOMAX_CONTROL
-
-
-class AlertsResponse(Response):
-    """Represents response to a device alerts request."""
-
-    __slots__ = ()
-
-    frame_type = FrameType.RESPONSE_ALERTS
+    frame_type = FrameType.RESPONSE_THERMOSTAT_PARAMETERS
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
-        return AlertsStructure(self).decode(message)[0]
+        return ThermostatParametersStructure(self).decode(message)[0]
 
 
-class SchedulesResponse(Response):
-    """Represents response to a device schedules request."""
+class UIDResponse(Response):
+    """Represents an UID response.
+
+    Contains product info and product UID.
+    """
 
     __slots__ = ()
 
-    frame_type = FrameType.RESPONSE_SCHEDULES
+    frame_type = FrameType.RESPONSE_UID
+
+    def create_message(self, data: dict[str, Any]) -> bytearray:
+        """Create a frame message."""
+        return ProductInfoStructure(self).encode(data)
 
     def decode_message(self, message: bytearray) -> dict[str, Any]:
         """Decode a frame message."""
-        return SchedulesStructure(self).decode(message)[0]
+        return ProductInfoStructure(self).decode(message)[0]

pyplumio/helpers/parameter.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 import asyncio
 from dataclasses import dataclass
 import logging
-from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, get_args
 
 from dataslots import dataslots
 from typing_extensions import TypeAlias
@@ -19,8 +19,8 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
-
-ParameterValue: TypeAlias = Union[int, float, bool, Literal["off", "on"]]
+NumericType: TypeAlias = Union[int, float]
+State: TypeAlias = Literal["on", "off"]
 ParameterT = TypeVar("ParameterT", bound="Parameter")
 
 
@@ -28,7 +28,7 @@ def unpack_parameter(
     data: bytearray, offset: int = 0, size: int = 1
 ) -> ParameterValues | None:
     """Unpack a device parameter."""
-    if not check_parameter(data[offset : offset + size * 3]):
+    if not validate_parameter(data[offset : offset + size * 3]):
         return None
 
     value = data[offset : offset + size]
@@ -42,14 +42,17 @@ def unpack_parameter(
     )
 
 
-def check_parameter(data: bytearray) -> bool:
+def validate_parameter(data: bytearray) -> bool:
     """Check if parameter contains any bytes besides 0xFF."""
     return any(x for x in data if x != BYTE_UNDEFINED)
 
 
-def _normalize_parameter_value(value: ParameterValue) -> int:
-    """Normalize a parameter value."""
-    if value in (STATE_OFF, STATE_ON):
+def parameter_value_to_int(value: NumericType | State | bool) -> int:
+    """Convert a parameter value to an integer.
+
+    If the value is STATE_OFF or STATE_ON, it returns 0 or 1 respectively.
+    """
+    if value in get_args(State):
         return 1 if value == STATE_ON else 0
 
     return int(value)
@@ -77,19 +80,11 @@ class ParameterDescription:
 class Parameter(ABC):
     """Represents a base parameter."""
 
-    __slots__ = (
-        "device",
-        "description",
-        "_pending_update",
-        "_previous_value",
-        "_index",
-        "_values",
-    )
+    __slots__ = ("device", "description", "_pending_update", "_index", "_values")
 
     device: Device
     description: ParameterDescription
     _pending_update: bool
-    _previous_value: int
     _index: int
     _values: ParameterValues
 
@@ -103,8 +98,8 @@ class Parameter(ABC):
         """Initialize a new parameter."""
         self.device = device
         self.description = description
+        self._index = index
         self._pending_update = False
-        self._previous_value = 0
         self._index = index
         self._values = values if values else ParameterValues(0, 0, 0)
 
@@ -127,9 +122,9 @@ class Parameter(ABC):
             handler = getattr(self.values, method_to_call)
             return handler(other)
 
-        if isinstance(other, (int, float, bool)) or other in (STATE_OFF, STATE_ON):
+        if isinstance(other, (int, float, bool)) or other in get_args(State):
             handler = getattr(self.values.value, method_to_call)
-            return handler(_normalize_parameter_value(other))
+            return handler(parameter_value_to_int(other))
         else:
             return NotImplemented
 
@@ -184,42 +179,44 @@ class Parameter(ABC):
         )
         return type(self)(self.device, self.description, values)
 
-    def validate(self, value: ParameterValue) -> int:
+    def validate(self, value: NumericType | State | bool) -> int:
         """Validate a parameter value."""
-        value = _normalize_parameter_value(value)
-        if value < self.values.min_value or value > self.values.max_value:
+        int_value = parameter_value_to_int(value)
+        if int_value < self.values.min_value or int_value > self.values.max_value:
             raise ValueError(
                 f"Invalid value: {value}. Must be between "
                 f"{self.min_value} and {self.max_value}."
             )
 
-        return value
+        return int_value
 
     async def set(self, value: Any, retries: int = 5, timeout: float = 5.0) -> bool:
         """Set a parameter value."""
-        return await self._try_set(self.validate(value), retries, timeout)
+        return await self._attempt_update(self.validate(value), retries, timeout)
 
     def set_nowait(self, value: Any, retries: int = 5, timeout: float = 5.0) -> None:
         """Set a parameter value without waiting."""
-        self.device.create_task(self._try_set(self.validate(value), retries, timeout))
+        self.device.create_task(
+            self._attempt_update(self.validate(value), retries, timeout)
+        )
 
-    async def _try_set(
-        self, value: Any, retries: int = 5, timeout: float = 5.0
+    async def _attempt_update(
+        self, value: int, retries: int = 5, timeout: float = 5.0
     ) -> bool:
-        """Try to set a parameter value."""
+        """Attempt to update a parameter value on the remote device."""
         if value == self.values.value:
             # Value is unchanged
             return True
 
-        self._previous_value = self._values.value
-        self._values.value = value
         self._pending_update = True
+        self._values.value = value
+        initial_retries = retries
         while self.pending_update:
             if retries <= 0:
                 _LOGGER.warning(
-                    "Unable to confirm that parameter '%s' was set after %d retries",
+                    "Unable to confirm update of '%s' parameter after %d retries",
                     self.description.name,
-                    retries,
+                    initial_retries,
                 )
                 return False
 
@@ -231,9 +228,7 @@ class Parameter(ABC):
 
     def update(self, values: ParameterValues) -> None:
         """Update the parameter values."""
-        if self.pending_update and self._previous_value != values.value:
-            self._pending_update = False
-
+        self._pending_update = False
         self._values = values
 
     @property
@@ -267,17 +262,17 @@ class Parameter(ABC):
 
     @property
     @abstractmethod
-    def value(self) -> Any:
+    def value(self) -> NumericType | State | bool:
         """Return the value."""
 
     @property
     @abstractmethod
-    def min_value(self) -> Any:
+    def min_value(self) -> NumericType | State | bool:
         """Return the minimum allowed value."""
 
     @property
     @abstractmethod
-    def max_value(self) -> Any:
+    def max_value(self) -> NumericType | State | bool:
         """Return the maximum allowed value."""
 
     @abstractmethod
@@ -301,13 +296,13 @@ class Number(Parameter):
     description: NumberDescription
 
     async def set(
-        self, value: int | float, retries: int = 5, timeout: float = 5.0
+        self, value: NumericType, retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
         return await super().set(value, retries, timeout)
 
     def set_nowait(
-        self, value: int | float, retries: int = 5, timeout: float = 5.0
+        self, value: NumericType, retries: int = 5, timeout: float = 5.0
     ) -> None:
         """Set a parameter value without waiting."""
         super().set_nowait(value, retries, timeout)
@@ -317,17 +312,17 @@ class Number(Parameter):
         return Request()
 
     @property
-    def value(self) -> int | float:
+    def value(self) -> NumericType:
         """Return the value."""
         return self.values.value
 
     @property
-    def min_value(self) -> int | float:
+    def min_value(self) -> NumericType:
         """Return the minimum allowed value."""
         return self.values.min_value
 
     @property
-    def max_value(self) -> int | float:
+    def max_value(self) -> NumericType:
         """Return the maximum allowed value."""
         return self.values.max_value
 
@@ -351,13 +346,13 @@ class Switch(Parameter):
     description: SwitchDescription
 
     async def set(
-        self, value: bool | Literal["off", "on"], retries: int = 5, timeout: float = 5.0
+        self, value: State | bool, retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
         return await super().set(value, retries, timeout)
 
     def set_nowait(
-        self, value: bool | Literal["off", "on"], retries: int = 5, timeout: float = 5.0
+        self, value: State | bool, retries: int = 5, timeout: float = 5.0
     ) -> None:
         """Set a switch value without waiting."""
         super().set_nowait(value, retries, timeout)
@@ -393,7 +388,7 @@ class Switch(Parameter):
         return Request()
 
     @property
-    def value(self) -> Literal["off", "on"]:
+    def value(self) -> State:
         """Return the value."""
         return STATE_ON if self.values.value == 1 else STATE_OFF
 

pyplumio/helpers/schedule.py

@@ -21,8 +21,7 @@ TIME_FORMAT: Final = "%H:%M"
 STATE_NIGHT: Final = "night"
 STATE_DAY: Final = "day"
 
-ON_STATES: Final = (STATE_ON, STATE_DAY)
-OFF_STATES: Final = (STATE_OFF, STATE_NIGHT)
+_ON_STATES: Final = {STATE_ON, STATE_DAY}
 
 ScheduleState: TypeAlias = Literal["on", "off", "day", "night"]
 Time = Annotated[str, "time in HH:MM format"]
@@ -113,7 +112,7 @@ class ScheduleDay(MutableMapping):
             )
 
         for index in _get_time_range(start, end):
-            self._intervals[index] = True if state in ON_STATES else False
+            self._intervals[index] = True if state in _ON_STATES else False
 
     def set_on(self, start: Time = "00:00", end: Time = "00:00") -> None:
         """Set a schedule interval state to 'on'."""

pyplumio/helpers/uid.py

@@ -1,4 +1,4 @@
-"""Contains an UID helpers."""
+"""Contains UID helpers."""
 
 from __future__ import annotations
 
@@ -18,18 +18,18 @@ def decode_uid(buffer: bytes) -> str:
 def _base5(buffer: bytes) -> str:
     """Encode bytes to a base5 encoded string."""
     number = int.from_bytes(buffer, byteorder="little")
-    output = ""
+    output = []
     while number:
-        output = BASE5_KEY[number & 0b00011111] + output
+        output.append(BASE5_KEY[number & 0b00011111])
         number >>= 5
 
-    return output
+    return "".join(reversed(output))
 
 
 def _crc16(buffer: bytes) -> bytes:
     """Return a CRC 16."""
     crc16 = reduce(_crc16_byte, buffer, CRC)
-    return crc16.to_bytes(byteorder="little", length=2)
+    return crc16.to_bytes(length=2, byteorder="little")
 
 
 def _crc16_byte(crc: int, byte: int) -> int: