PyPlumIO 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

{PyPlumIO-0.5.5.dist-info → PyPlumIO-0.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.5.5
+Version: 0.5.7
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -44,17 +44,12 @@ Devices can be connected directly via RS-485 to USB adapter or through network b
 ![RS-485 converters](https://raw.githubusercontent.com/denpamusic/PyPlumIO/main/images/rs485.png)
 
 ## Table of contents
-- [Usage](https://pyplumio.denpa.pro/usage.html)
-  - [Connecting](https://pyplumio.denpa.pro/usage.html#connecting)
-  - [Reading](https://pyplumio.denpa.pro/usage.html#reading)
-  - [Writing](https://pyplumio.denpa.pro/usage.html#writing)
-  - [Parameters](https://pyplumio.denpa.pro/usage.html#parameters)
-  - [Callbacks](https://pyplumio.denpa.pro/usage.html#callbacks)
-  - [Filters](https://pyplumio.denpa.pro/usage.html#filters)
-  - [Regulator Data](https://pyplumio.denpa.pro/usage.html#regulator-data)
-  - [Mixers/Thermostats](https://pyplumio.denpa.pro/usage.html#mixers-thermostats)
-  - [Schedules](https://pyplumio.denpa.pro/usage.html#schedules)
-  - [Network Information](https://pyplumio.denpa.pro/usage.html#network-information)
+- [Connecting](https://pyplumio.denpa.pro/connecting.html)
+- [Reading](https://pyplumio.denpa.pro/reading.html)
+- [Writing](https://pyplumio.denpa.pro/writing.html)
+- [Callbacks](https://pyplumio.denpa.pro/callbacks.html)
+- [Mixers/Thermostats](https://pyplumio.denpa.pro/mixers_thermostats.html)
+- [Schedules](https://pyplumio.denpa.pro/schedules.html)
 - [Protocol](https://pyplumio.denpa.pro/protocol.html)
   - [Frame Structure](https://pyplumio.denpa.pro/protocol.html#frame-structure)
   - [Requests and Responses](https://pyplumio.denpa.pro/protocol.html#requests-and-responses)

PyPlumIO-0.5.7.dist-info/RECORD

@@ -0,0 +1,60 @@
+pyplumio/__init__.py,sha256=JpT80zjHEk7N9e5sY4N53sOyUr8D7K3wU6cShkySeqI,3846
+pyplumio/__main__.py,sha256=oop76iR-XDHhMFhW4LO8-xTnBHsqzUQ5VVh__94OaqY,499
+pyplumio/_version.py,sha256=WG2gUkVRG4TIqG0-naezn012emNIbgERkkZYUI1CHww,411
+pyplumio/connection.py,sha256=gxf4qoVRDz_ZYOEnGGnrs0QCGHxpclNWXE7_yzWDhN0,6522
+pyplumio/const.py,sha256=lDHu7QkP8zKWDc5anOgyQGiXcF4Unv7hyibXfmoPDQk,3832
+pyplumio/exceptions.py,sha256=cpLGRl9db6cU1Z6WXhQ7yl1V7Te193QymWiOoRF8KAI,798
+pyplumio/filters.py,sha256=Q8ffCv7vH0wgTwrPKEfp861E44ev5yi41W9x19VKckc,10284
+pyplumio/protocol.py,sha256=MuhnZ7fFT318X916-kH3TlMmJtVFE20PaHsbmkzKT84,8699
+pyplumio/stream.py,sha256=g_lZkMWuYmFQ4mZrkP6kLxrmWpnQrLmiBIv0f-to38U,4024
+pyplumio/utils.py,sha256=5QF-oJar4DfaaUHqrMIfKPFJFWGBLQfgo4nYo4doJWw,651
+pyplumio/devices/__init__.py,sha256=DsPes_1xsfqW3RCfP2lnQcrdoA8ej16UNaNW89UFMWo,6488
+pyplumio/devices/ecomax.py,sha256=wjm66TL9X_QU9KbmTD7fwsoACKNjM_K9nghzOlE1TEw,16469
+pyplumio/devices/ecoster.py,sha256=QH68bzs199x9Id-wOY6J5WddyR69STNQi8SxaWDwKG4,312
+pyplumio/devices/mixer.py,sha256=7PWwaMQ-cezvIRNot3OkemipT65lLFv4kTXPXAaH4oY,2962
+pyplumio/devices/thermostat.py,sha256=BIYuSuv-1bUjGbMmWkWR0ej-57chYO9YPM5W-vAy55M,2418
+pyplumio/frames/__init__.py,sha256=M0kTQii4Ver3WRCOC8eeXOb910mCDOLsUbJarksT72g,7410
+pyplumio/frames/messages.py,sha256=BS5d4M1pz99pNQhu8OgE2Q6ejNO8qT2R621lUPvD9fs,3672
+pyplumio/frames/requests.py,sha256=A7ixLYAzY-nebJ9DcLH55RkhNNum8JnBGr5Dv2SP4SU,7333
+pyplumio/frames/responses.py,sha256=z7m0MRUVckadoghzm9por0Wn879z1C9zGk5lPZfgFqE,6647
+pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
+pyplumio/helpers/data_types.py,sha256=AGMDOlz7B_dxf2qsyfUrpb2aN9I-H9tIj40twt4ankg,7903
+pyplumio/helpers/event_manager.py,sha256=uxeFFsyIiZ33f22Q_Wx0PI1aoOI2lkZa2fPZ0QGCCZw,5980
+pyplumio/helpers/factory.py,sha256=403RYqlKbWRmL-RngzL1e2p5iI5_JTzwf65HeNxHfwM,527
+pyplumio/helpers/parameter.py,sha256=5FXrftafV31YaFx-UamhBncrZjWeMOaHsmsoYIcd3VY,8549
+pyplumio/helpers/schedule.py,sha256=gNZcgLfa-D3Y6Vx77U61cm6bMlD5iIxl0f1m5FZIkBM,4859
+pyplumio/helpers/task_manager.py,sha256=fZyBmHik7rU9Kb4EECQWqVrJPUlEtEyxrEUJcf8RVYc,1072
+pyplumio/helpers/timeout.py,sha256=UstSwBfrLO_YhUHHvhIgunAw89s6PocR80nmU5LN4oI,915
+pyplumio/helpers/typing.py,sha256=gn7TWudOAqViQYMQk1vCk9_JnsFs8Q1KK3FrvkyI8AI,478
+pyplumio/helpers/uid.py,sha256=FTwuET3WLNyEkAHpxD4ZA3hu-l_JCS6pq12xibAQs6s,974
+pyplumio/structures/__init__.py,sha256=L976WdfoNb_Mmv-pN86XKBLEZydsVlD_Xlw85cnCS3E,1247
+pyplumio/structures/alerts.py,sha256=gkUOYCFt5PvLusrrI9jw3qjvvbVYaX2BgUztW9CkYC0,2986
+pyplumio/structures/boiler_load.py,sha256=tRlKr5gZQ-UZh042f98wH3ctOuXgCAb16ne_zFP5I28,860
+pyplumio/structures/boiler_power.py,sha256=BRl3QkPtoFoEVHUeWN5KKkxATIO4-EZB-0fEsvRKECI,923
+pyplumio/structures/ecomax_parameters.py,sha256=71c-dMSx3QebyAF1okO5hc6DQcJ9V-c3NRkTN8thSYY,25939
+pyplumio/structures/fan_power.py,sha256=cBLmns_nh8I5eDNehFM1QMe5eqlUC-QBBm1i0kTbj38,893
+pyplumio/structures/frame_versions.py,sha256=SkHrgehJbf14Qf_uKY8zlZp8d8WjgAq3Swwjf1Y1trw,1572
+pyplumio/structures/fuel_consumption.py,sha256=qxT8vtOX6VIv6MgvTalYlsN7FIBzXL3ba8VHO2b6mbs,998
+pyplumio/structures/fuel_level.py,sha256=XqqciKIBM8-zmG_JNc9ILff3Rgd4aCgvht7STrw9Dz0,851
+pyplumio/structures/lambda_sensor.py,sha256=2aEZjY8y7qV76Ky4gE4Ui7zWyXxCQRdtMingtMBKhF0,1475
+pyplumio/structures/mixer_parameters.py,sha256=ssYHpReiPC7kpNiCwgqMkbR8Wwkqh4wCQqhKUbLWPQg,8194
+pyplumio/structures/mixer_sensors.py,sha256=sKm1gIoRcCLVad-9MqOkEwu_bXIZy-3Kbi2kCd5wOkM,2243
+pyplumio/structures/modules.py,sha256=y1WRxKk3vW3erquzsVd4G7mDLlna8DttueeUu0jCgYw,2532
+pyplumio/structures/network_info.py,sha256=O09zE4AzU-yEi_yMB4VPN-2_BYNasCAbOBANLJbh4P0,4013
+pyplumio/structures/output_flags.py,sha256=JY_IVncL_ZnIV2xXfEXLDK8x2tPulIW1PZpWVHgC-C4,1367
+pyplumio/structures/outputs.py,sha256=dS0dYsl9bWLuZmj5rt0Dcg1chyQhjFOIwA6KU4Yw76g,1938
+pyplumio/structures/pending_alerts.py,sha256=L_uaizbL_H3gYkpPBN0T0H8Q4jNo17-5-QamiF5tQO0,761
+pyplumio/structures/product_info.py,sha256=hkUGlbEr-OtpCHozGI_8R_uLB5cyYwe9dJ1Xz-Sqdoc,2396
+pyplumio/structures/program_version.py,sha256=5gOmKpbr2ftsXtJ5Hqkg__30DRYtB-CAx5sXIvCLQeM,2477
+pyplumio/structures/regulator_data.py,sha256=9rEy_JLij9XE2Kyc5jgWAfJKJG3OmL2W2Bix6t2zKnU,2544
+pyplumio/structures/regulator_data_schema.py,sha256=W2b3-n3PZoo4pU2esqeCWP-_zz1AxymJ9Y6fcS_y6bg,1517
+pyplumio/structures/schedules.py,sha256=4I74MHutWcb_i-z2ZvDxdavSnOUivWRBhvjRnK5aKK0,6125
+pyplumio/structures/statuses.py,sha256=IWcQ1TNfvhVitF_vxTeF3c4txpU54NOyi4l445SJVk8,1188
+pyplumio/structures/temperatures.py,sha256=znL_gSfVeO8hAvl2GYRyRiYC3E3PSS6JmJXAJoTYea8,2359
+pyplumio/structures/thermostat_parameters.py,sha256=mqoqLSAPW3TfuFImEHGWmvvd-LCPR6pFcfH0Y8kd0Xg,7691
+pyplumio/structures/thermostat_sensors.py,sha256=sEH42iq05Wijfhfrv9o4iJcxX8EOcPoWcLpzUpq3qQ8,3071
+PyPlumIO-0.5.7.dist-info/LICENSE,sha256=g56wJgobsehVtkJD8MhM6isAnsdOUmRPv7fIaXI4Joo,1067
+PyPlumIO-0.5.7.dist-info/METADATA,sha256=YVfg3gm8Tfq0l-953p69oGyJld0ihjaaj9R1PPW8HVY,4463
+PyPlumIO-0.5.7.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+PyPlumIO-0.5.7.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.7.dist-info/RECORD,,

pyplumio/__init__.py

@@ -3,39 +3,106 @@ from __future__ import annotations
 
 from pyplumio._version import __version__, __version_tuple__
 from pyplumio.connection import Connection, SerialConnection, TcpConnection
+from pyplumio.protocol import AsyncProtocol, Protocol
 from pyplumio.structures.network_info import EthernetParameters, WirelessParameters
 
 
 def open_serial_connection(
-    device: str, baudrate: int = 115200, **kwargs
+    device: str,
+    baudrate: int = 115200,
+    *,
+    ethernet_parameters: EthernetParameters | None = None,
+    wireless_parameters: WirelessParameters | None = None,
+    reconnect_on_failure: bool = True,
+    protocol: type[Protocol] = AsyncProtocol,
+    **kwargs,
 ) -> SerialConnection:
-    """Create a serial connection."""
-    return SerialConnection(device, baudrate, **kwargs)
+    r"""Create a serial connection.
 
+    :param device: Serial port device name. e. g. /dev/ttyUSB0
+    :type device: str
+    :param baudrate: Serial port baud rate, defaults to 115200
+    :type baudrate: int, optional
+    :param ethernet_parameters: Ethernet parameters to send to an
+        ecoMAX controller
+    :type ethernet_parameters: EthernetParameters, optional
+    :param wireless_parameters: Wireless parameters to send to an
+        ecoMAX controller
+    :type wireless_parameters: WirelessParameters, optional
+    :param reconnect_on_failure: `True` if PyPlumIO should try
+        reconnecting on failure, otherwise `False`, default to `True`
+    :type reconnect_on_failure: bool, optional
+    :param protocol: Protocol that will be used for communication with
+        the ecoMAX controller, default to AsyncProtocol
+    :type protocol: Protocol, optional
+    :param \**kwargs: Additional keyword arguments to be passed to
+        serial_asyncio.open_serial_connection()
+    :return: An instance of serial connection
+    :rtype: SerialConnection
+    """
+    return SerialConnection(
+        device,
+        baudrate,
+        ethernet_parameters=ethernet_parameters,
+        wireless_parameters=wireless_parameters,
+        reconnect_on_failure=reconnect_on_failure,
+        protocol=protocol,
+        **kwargs,
+    )
 
-def open_tcp_connection(host: str, port: int, **kwargs) -> TcpConnection:
-    """Create a TCP connection."""
-    return TcpConnection(host, port, **kwargs)
 
+def open_tcp_connection(
+    host: str,
+    port: int,
+    *,
+    ethernet_parameters: EthernetParameters | None = None,
+    wireless_parameters: WirelessParameters | None = None,
+    reconnect_on_failure: bool = True,
+    protocol: type[Protocol] = AsyncProtocol,
+    **kwargs,
+) -> TcpConnection:
+    r"""Create a TCP connection.
 
-def ethernet_parameters(**kwargs) -> EthernetParameters:
-    """Return an instance of ethernet parameters dataclass."""
-    return EthernetParameters(status=True, **kwargs)
-
-
-def wireless_parameters(**kwargs) -> WirelessParameters:
-    """Return an instance of wireless parameters dataclass."""
-    return WirelessParameters(status=True, **kwargs)
+    :param host: IP address or host name of the remote RS-485 server
+    :type host: str
+    :param port: Port that remote RS-485 server is listening to
+    :type port: int
+    :param ethernet_parameters: Ethernet parameters to send to an
+        ecoMAX controller
+    :type ethernet_parameters: EthernetParameters, optional
+    :param wireless_parameters: Wireless parameters to send to an
+        ecoMAX controller
+    :type wireless_parameters: WirelessParameters, optional
+    :param reconnect_on_failure: `True` if PyPlumIO should try
+        reconnecting on failure, otherwise `False`, default to `True`
+    :type reconnect_on_failure: bool, optional
+    :param protocol: Protocol that will be used for communication with
+        the ecoMAX controller, default to AsyncProtocol
+    :type protocol: Protocol, optional
+    :param \**kwargs: Additional keyword arguments to be passed to
+        asyncio.open_connection()
+    :return: An instance of TCP connection
+    :rtype: TcpConnection
+    """
+    return TcpConnection(
+        host,
+        port,
+        ethernet_parameters=ethernet_parameters,
+        wireless_parameters=wireless_parameters,
+        reconnect_on_failure=reconnect_on_failure,
+        protocol=protocol,
+        **kwargs,
+    )
 
 
 __all__ = [
     "Connection",
     "SerialConnection",
     "TcpConnection",
+    "EthernetParameters",
+    "WirelessParameters",
     "open_serial_connection",
     "open_tcp_connection",
-    "ethernet_parameters",
-    "wireless_parameters",
     "__version__",
     "__version_tuple__",
 ]

pyplumio/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.5'
-__version_tuple__ = version_tuple = (0, 5, 5)
+__version__ = version = '0.5.7'
+__version_tuple__ = version_tuple = (0, 5, 7)

pyplumio/connection.py

@@ -12,7 +12,8 @@ import serial_asyncio
 
 from pyplumio.exceptions import ConnectionFailedError
 from pyplumio.helpers.timeout import timeout
-from pyplumio.protocol import Protocol
+from pyplumio.protocol import AsyncProtocol, Protocol
+from pyplumio.structures.network_info import EthernetParameters, WirelessParameters
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -26,29 +27,28 @@ class Connection(ABC):
     All specific connection classes MUST be inherited from this class.
     """
 
-    __slots__ = ("_kwargs", "_protocol", "_closing", "_reconnect_on_failure")
-
-    _kwargs: MutableMapping[str, Any]
-    _protocol: Protocol
     _closing: bool
+    _protocol: Protocol
     _reconnect_on_failure: bool
+    _kwargs: MutableMapping[str, Any]
 
     def __init__(
         self,
+        ethernet_parameters: EthernetParameters | None = None,
+        wireless_parameters: WirelessParameters | None = None,
         reconnect_on_failure: bool = True,
-        ethernet_parameters=None,
-        wireless_parameters=None,
+        protocol: type[Protocol] = AsyncProtocol,
         **kwargs,
     ):
         """Initialize a new connection."""
-        self._kwargs = kwargs
         self._closing = False
-        self._protocol = Protocol(
+        self._reconnect_on_failure = reconnect_on_failure
+        self._protocol = protocol(
             self._connection_lost,
             ethernet_parameters,
             wireless_parameters,
         )
-        self._reconnect_on_failure = reconnect_on_failure
+        self._kwargs = kwargs
 
     async def __aenter__(self):
         """Provide an entry point for the context manager."""
@@ -125,9 +125,25 @@ class TcpConnection(Connection):
     host: str
     port: int
 
-    def __init__(self, host: str, port: int, **kwargs):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        *,
+        ethernet_parameters: EthernetParameters | None = None,
+        wireless_parameters: WirelessParameters | None = None,
+        reconnect_on_failure: bool = True,
+        protocol: type[Protocol] = AsyncProtocol,
+        **kwargs,
+    ):
         """Initialize a new TCP connection."""
-        super().__init__(**kwargs)
+        super().__init__(
+            ethernet_parameters,
+            wireless_parameters,
+            reconnect_on_failure,
+            protocol,
+            **kwargs,
+        )
         self.host = host
         self.port = port
 
@@ -153,9 +169,25 @@ class SerialConnection(Connection):
     device: str
     baudrate: int
 
-    def __init__(self, device: str, baudrate: int = 115200, **kwargs):
+    def __init__(
+        self,
+        device: str,
+        baudrate: int = 115200,
+        *,
+        ethernet_parameters: EthernetParameters | None = None,
+        wireless_parameters: WirelessParameters | None = None,
+        reconnect_on_failure: bool = True,
+        protocol: type[Protocol] = AsyncProtocol,
+        **kwargs,
+    ):
         """Initialize a new serial connection."""
-        super().__init__(**kwargs)
+        super().__init__(
+            ethernet_parameters,
+            wireless_parameters,
+            reconnect_on_failure,
+            protocol,
+            **kwargs,
+        )
         self.device = device
         self.baudrate = baudrate
 

pyplumio/const.py

@@ -133,7 +133,7 @@ class FrameType(IntEnum):
     REQUEST_ECOMAX_CONTROL = 59
     REQUEST_ALERTS = 61
     REQUEST_PROGRAM_VERSION = 64
-    REQUEST_DATA_SCHEMA = 85
+    REQUEST_REGULATOR_DATA_SCHEMA = 85
     REQUEST_THERMOSTAT_PARAMETERS = 92
     REQUEST_SET_THERMOSTAT_PARAMETER = 93
     RESPONSE_DEVICE_AVAILABLE = 176
@@ -147,7 +147,7 @@ class FrameType(IntEnum):
     RESPONSE_ECOMAX_CONTROL = 187
     RESPONSE_ALERTS = 189
     RESPONSE_PROGRAM_VERSION = 192
-    RESPONSE_DATA_SCHEMA = 213
+    RESPONSE_REGULATOR_DATA_SCHEMA = 213
     RESPONSE_THERMOSTAT_PARAMETERS = 220
     RESPONSE_SET_THERMOSTAT_PARAMETER = 221
     MESSAGE_REGULATOR_DATA = 8

pyplumio/devices/__init__.py

@@ -42,8 +42,6 @@ def get_device_handler_and_name(device_type: int) -> tuple[str, str]:
 class Device(ABC, EventManager):
     """Represents a device."""
 
-    __slots__ = ("queue",)
-
     queue: asyncio.Queue
 
     def __init__(self, queue: asyncio.Queue):
@@ -60,8 +58,23 @@ class Device(ABC, EventManager):
     ) -> bool:
         """Set a parameter value.
 
-        Name should point to a valid parameter object, otherwise
-        raise ParameterNotFoundError.
+        :param name: Name of the parameter
+        :type name: str
+        :param value: New value for the parameter
+        :type value: int | float | bool | Literal["on"] | Literal["off"]
+        :param timeout: Wait this amount of seconds for confirmation,
+            defaults to `None`
+        :type timeout: float, optional
+        :param retries: Try setting parameter for this amount of
+            times, defaults to 5
+        :type retries: int, optional
+        :return: `True` if parameter was successfully set, `False`
+            otherwise.
+        :rtype: bool
+        :raise pyplumio.exceptions.ParameterNotFoundError: when
+            parameter with the specified name is not found
+        :raise asyncio.TimeoutError: when waiting past specified timeout
+        :raise ValueError: when a new value is outside of allowed range
         """
         parameter = await self.get(name, timeout=timeout)
         if not isinstance(parameter, Parameter):
@@ -76,15 +89,30 @@ class Device(ABC, EventManager):
         timeout: float | None = None,
         retries: int = SET_RETRIES,
     ) -> None:
-        """Set a parameter value without waiting for the result."""
+        """Set a parameter value without waiting for the result.
+
+        :param name: Name of the parameter
+        :type name: str
+        :param value: New value for the parameter
+        :type value: int | float | bool | Literal["on"] | Literal["off"]
+        :param timeout: Wait this amount of seconds for confirmation.
+            As this method operates in the background without waiting,
+            this value is used to determine failure when
+            retrying and doesn't block, defaults to `None`
+        :type timeout: float, optional
+        :param retries: Try setting parameter for this amount of
+            times, defaults to 5
+        :type retries: int, optional
+        :return: `True` if parameter was successfully set, `False`
+            otherwise.
+        :rtype: bool
+        """
         self.create_task(self.set(name, value, timeout, retries))
 
 
-class Addressable(Device, ABC):
+class AddressableDevice(Device, ABC):
     """Represents an addressable device."""
 
-    __slots__ = ("address", "_network", "_setup_frames")
-
     address: ClassVar[int]
     _network: NetworkInfo
     _setup_frames: Iterable[DataFrameDescription]
@@ -153,12 +181,10 @@ class Addressable(Device, ABC):
 class SubDevice(Device, ABC):
     """Represents the sub-device."""
 
-    __slots__ = ("parent", "index")
-
-    parent: Addressable
+    parent: AddressableDevice
     index: int
 
-    def __init__(self, queue: asyncio.Queue, parent: Addressable, index: int = 0):
+    def __init__(self, queue: asyncio.Queue, parent: AddressableDevice, index: int = 0):
         """Initialize a new sub-device object."""
         super().__init__(queue)
         self.parent = parent

pyplumio/devices/ecomax.py

@@ -16,7 +16,7 @@ from pyplumio.const import (
     DeviceType,
     FrameType,
 )
-from pyplumio.devices import Addressable
+from pyplumio.devices import AddressableDevice
 from pyplumio.devices.mixer import Mixer
 from pyplumio.devices.thermostat import Thermostat
 from pyplumio.filters import on_change
@@ -32,7 +32,6 @@ from pyplumio.helpers.parameter import ParameterValues
 from pyplumio.helpers.schedule import Schedule, ScheduleDay
 from pyplumio.helpers.typing import EventDataType
 from pyplumio.structures.alerts import ATTR_ALERTS
-from pyplumio.structures.data_schema import ATTR_SCHEMA
 from pyplumio.structures.ecomax_parameters import (
     ATTR_ECOMAX_CONTROL,
     ATTR_ECOMAX_PARAMETERS,
@@ -49,6 +48,7 @@ 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,
@@ -73,7 +73,7 @@ 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_DATA_SCHEMA, provides=ATTR_SCHEMA
+        frame_type=FrameType.REQUEST_REGULATOR_DATA_SCHEMA, provides=ATTR_REGDATA_SCHEMA
     ),
     DataFrameDescription(
         frame_type=FrameType.REQUEST_ECOMAX_PARAMETERS, provides=ATTR_ECOMAX_PARAMETERS
@@ -95,11 +95,9 @@ SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
 _LOGGER = logging.getLogger(__name__)
 
 
-class EcoMAX(Addressable):
+class EcoMAX(AddressableDevice):
     """Represents an ecoMAX controller."""
 
-    __slots__ = ("_frame_versions", "_fuel_burned_timestamp_ns")
-
     address: ClassVar[int] = DeviceType.ECOMAX
     _setup_frames: Iterable[DataFrameDescription] = SETUP_FRAME_TYPES
     _frame_versions: dict[int, int]

pyplumio/devices/ecoster.py

@@ -4,10 +4,10 @@ from __future__ import annotations
 from typing import ClassVar
 
 from pyplumio.const import DeviceType
-from pyplumio.devices import Addressable
+from pyplumio.devices import AddressableDevice
 
 
-class EcoSTER(Addressable):
+class EcoSTER(AddressableDevice):
     """Represents an ecoSTER thermostat."""
 
     address: ClassVar[int] = DeviceType.ECOSTER

pyplumio/devices/mixer.py

@@ -5,7 +5,7 @@ import asyncio
 import logging
 from typing import Sequence
 
-from pyplumio.devices import Addressable, SubDevice
+from pyplumio.devices import AddressableDevice, SubDevice
 from pyplumio.helpers.parameter import ParameterValues
 from pyplumio.helpers.typing import EventDataType
 from pyplumio.structures.mixer_parameters import (
@@ -24,7 +24,7 @@ _LOGGER = logging.getLogger(__name__)
 class Mixer(SubDevice):
     """Represents an mixer."""
 
-    def __init__(self, queue: asyncio.Queue, parent: Addressable, index: int = 0):
+    def __init__(self, queue: asyncio.Queue, parent: AddressableDevice, index: int = 0):
         """Initialize a new mixer."""
         super().__init__(queue, parent, index)
         self.subscribe(ATTR_MIXER_SENSORS, self._handle_sensors)

pyplumio/devices/thermostat.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import asyncio
 from typing import Sequence
 
-from pyplumio.devices import Addressable, SubDevice
+from pyplumio.devices import AddressableDevice, SubDevice
 from pyplumio.helpers.parameter import ParameterValues
 from pyplumio.helpers.typing import EventDataType
 from pyplumio.structures.thermostat_parameters import (
@@ -20,7 +20,7 @@ from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTAT_SENSORS
 class Thermostat(SubDevice):
     """Represents a thermostat."""
 
-    def __init__(self, queue: asyncio.Queue, parent: Addressable, index: int = 0):
+    def __init__(self, queue: asyncio.Queue, parent: AddressableDevice, index: int = 0):
         """Initialize a new thermostat."""
         super().__init__(queue, parent, index)
         self.subscribe(ATTR_THERMOSTAT_SENSORS, self._handle_sensors)

pyplumio/filters.py

@@ -96,6 +96,8 @@ class _OnChange(Filter):
     previous callback call.
     """
 
+    __slots__ = ()
+
     async def __call__(self, new_value):
         """Set a new value for the callback."""
         if self._value == UNDEFINED or _significantly_changed(self._value, new_value):
@@ -109,6 +111,11 @@ def on_change(callback: EventCallbackType) -> _OnChange:
 
     A callback function will only be called if value is changed from the
     previous call.
+
+    :param callback: A callback function to be awaited on value change
+    :type callback: Callable[[Any], Awaitable[Any]]
+    :return: A instance of callable filter
+    :rtype: _OnChange
     """
     return _OnChange(callback)
 
@@ -125,7 +132,7 @@ class _Debounce(Filter):
     _calls: int
     _min_calls: int
 
-    def __init__(self, callback: EventCallbackType, min_calls: int = 3):
+    def __init__(self, callback: EventCallbackType, min_calls: int):
         """Initialize a new debounce filter."""
         super().__init__(callback)
         self._calls = 0
@@ -149,6 +156,14 @@ def debounce(callback: EventCallbackType, min_calls) -> _Debounce:
 
     A callback function will only called once value is stabilized
     across multiple filter calls.
+
+    :param callback: A callback function to be awaited on value change
+    :type callback: Callable[[Any], Awaitable[Any]]
+    :param min_calls: Value shouldn't change for this amount of
+        filter calls
+    :type min_calls: int
+    :return: A instance of callable filter
+    :rtype: _Debounce
     """
     return _Debounce(callback, min_calls)
 
@@ -187,6 +202,15 @@ def throttle(callback: EventCallbackType, seconds: float) -> _Throttle:
 
     A callback function will only be called once a certain amount of
     seconds passed since the last call.
+
+    :param callback: A callback function that will be awaited once
+        filter conditions are fulfilled
+    :type callback: Callable[[Any], Awaitable[Any]]
+    :param seconds: A callback will be awaited at most once per
+        this amount of seconds
+    :type seconds: float
+    :return: A instance of callable filter
+    :rtype: _Throttle
     """
     return _Throttle(callback, seconds)
 
@@ -197,6 +221,8 @@ class _Delta(Filter):
     Calls a callback with a difference between two subsequent values.
     """
 
+    __slots__ = ()
+
     async def __call__(self, new_value):
         """Set a new value for the callback."""
         if self._value == UNDEFINED or _significantly_changed(self._value, new_value):
@@ -214,6 +240,12 @@ def delta(callback: EventCallbackType) -> _Delta:
 
     A callback function will be called with a difference between two
     subsequent value.
+
+    :param callback: A callback function that will be awaited with
+        difference between values in two subsequent calls
+    :type callback: Callable[[Any], Awaitable[Any]]
+    :return: A instance of callable filter
+    :rtype: _Delta
     """
     return _Delta(callback)
 
@@ -259,7 +291,16 @@ def aggregate(callback: EventCallbackType, seconds: float) -> _Aggregate:
     """An aggregate filter.
 
     A callback function will be called with a sum of values collected
-    over a specified time period.
+    over a specified time period. Can only be used with numeric values.
+
+    :param callback: A callback function to be awaited once filter
+        conditions are fulfilled
+    :type callback: Callable[[Any], Awaitable[Any]]
+    :param seconds: A callback will be awaited with a sum of values
+        aggregated over this amount of seconds.
+    :type seconds: float
+    :return: A instance of callable filter
+    :rtype: _Aggregate
     """
     return _Aggregate(callback, seconds)
 
@@ -272,6 +313,10 @@ class _Custom(Filter):
     returns true.
     """
 
+    __slots__ = ("_filter_fn",)
+
+    filter_fn: Callable[[Any], bool]
+
     def __init__(self, callback: EventCallbackType, filter_fn: Callable[[Any], bool]):
         """Initialize a new custom filter."""
         super().__init__(callback)
@@ -289,5 +334,14 @@ def custom(callback: EventCallbackType, filter_fn: Callable[[Any], bool]) -> _Cu
     A callback function will be called when user-defined filter
     function, that's being called with the value as an argument,
     returns true.
+
+    :param callback: A callback function to be awaited when
+        filter function return true
+    :type callback: Callable[[Any], Awaitable[Any]]
+    :param filter_fn: Filter function, that will be called with a
+        value and should return `True` to await filter's callback
+    :type filter_fn: Callable[[Any], bool]
+    :return: A instance of callable filter
+    :rtype: _Custom
     """
     return _Custom(callback, filter_fn)