PyPlumIO 0.5.54__py3-none-any.whl → 0.5.56__py3-none-any.whl

pyplumio/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.54'
-__version_tuple__ = version_tuple = (0, 5, 54)
+__version__ = version = '0.5.56'
+__version_tuple__ = version_tuple = (0, 5, 56)
 
 __commit_id__ = commit_id = None

pyplumio/devices/ecomax.py

@@ -139,6 +139,8 @@ REQUIRED: tuple[DataFrameDescription, ...] = (
 
 REQUIRED_TYPES = [description.frame_type for description in REQUIRED]
 
+SETUP_TIMEOUT: Final = 60.0
+
 
 class EcoMAX(PhysicalDevice):
     """Represents an ecoMAX controller."""
@@ -233,10 +235,19 @@ class EcoMAX(PhysicalDevice):
         await super().shutdown()
 
     @event_listener
-    async def on_event_setup(self, setup: bool) -> None:
+    async def on_event_setup(self, setup: bool) -> bool:
         """Request frames required to set up an ecoMAX entry."""
         _LOGGER.debug("Setting up device entry")
-        await self.wait_for(ATTR_SENSORS, timeout=30.0)
+
+        try:
+            await self.wait_for(ATTR_SENSORS, timeout=SETUP_TIMEOUT)
+        except asyncio.TimeoutError:
+            _LOGGER.error(
+                "Could not setup device entry; no response from device for %u seconds",
+                SETUP_TIMEOUT,
+            )
+            return False
+
         results = await asyncio.gather(
             *(
                 self.request(description.provides, description.frame_type)
@@ -253,6 +264,7 @@ class EcoMAX(PhysicalDevice):
             self.dispatch_nowait(ATTR_FRAME_ERRORS, errors)
 
         _LOGGER.debug("Device entry setup done")
+        return True
 
     @event_listener
     async def on_event_ecomax_parameters(

pyplumio/protocol.py

@@ -5,9 +5,12 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import asyncio
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from datetime import datetime
 import logging
+from typing import Any, Final, Literal
 
+from dataslots import dataslots
 from typing_extensions import TypeAlias
 
 from pyplumio.const import ATTR_CONNECTED, ATTR_SETUP, DeviceType
@@ -23,6 +26,7 @@ from pyplumio.structures.network_info import (
     NetworkInfo,
     WirelessParameters,
 )
+from pyplumio.structures.regulator_data import ATTR_REGDATA
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -114,6 +118,87 @@ class Queues:
         await asyncio.gather(self.read.join(), self.write.join())
 
 
+NEVER: Final = "never"
+
+
+@dataslots
+@dataclass
+class Statistics:
+    """Represents a connection statistics.
+
+    :param received_bytes: Number of received bytes. Resets on reconnect.
+    :type received_bytes: int
+    :param received_frames: Number of received frames. Resets on reconnect.
+    :type received_frames: int
+    :param sent_bytes: Number of sent bytes.  Resets on reconnect.
+    :type sent_bytes: int
+    :param sent_frames: Number of sent frames. Resets on reconnect.
+    :type sent_frames: int
+    :param failed_frames: Number of failed frames. Resets on reconnect.
+    :type failed_frames: int
+    :param connected_since: Datetime object representing connection time.
+    :type connected_since: datetime.datetime | Literal["never"]
+    :param connection_loss_at: Datetime object representing last connection loss event.
+    :type connection_loss_at: datetime.datetime | Literal["never"]
+    :param connection_losses: Number of connection lost event.
+    :type connection_losses: int
+    :param devices: Contains list of statistics for connected devices.
+    :type devices: list[DeviceStatistics]
+    """
+
+    received_bytes: int = 0
+    received_frames: int = 0
+    sent_bytes: int = 0
+    sent_frames: int = 0
+    failed_frames: int = 0
+    connected_since: datetime | Literal["never"] = NEVER
+    connection_loss_at: datetime | Literal["never"] = NEVER
+    connection_losses: int = 0
+    devices: list[DeviceStatistics] = field(default_factory=list)
+
+    def update_transfer_statistics(
+        self, sent: Frame | None = None, received: Frame | None = None
+    ) -> None:
+        """Update transfer statistics."""
+        if sent:
+            self.sent_bytes += sent.length
+            self.sent_frames += 1
+
+        if received:
+            self.received_bytes += received.length
+            self.received_frames += 1
+
+    def reset_transfer_statistics(self) -> None:
+        """Reset transfer statistics."""
+        self.sent_bytes = 0
+        self.sent_frames = 0
+        self.received_bytes = 0
+        self.received_frames = 0
+        self.failed_frames = 0
+
+
+@dataslots
+@dataclass
+class DeviceStatistics:
+    """Represents a device statistics.
+
+    :param name: Device name.
+    :type name: str
+    :param connected_since: Datetime object representing connection time.
+    :type connected_since: datetime.datetime | Literal["never"]
+    :param last_seen: Datetime object representing time when device was last seen.
+    :type last_seen: datetime.datetime | Literal["never"]
+    """
+
+    name: str
+    connected_since: datetime | Literal["never"] = NEVER
+    last_seen: datetime | Literal["never"] = NEVER
+
+    async def update_last_seen(self, data: Any) -> None:
+        """Update last seen property."""
+        self.last_seen = datetime.now()
+
+
 class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     """Represents an async protocol.
 
@@ -134,6 +219,7 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     _network: NetworkInfo
     _queues: Queues
     _entry_lock: asyncio.Lock
+    _statistics: Statistics
 
     def __init__(
         self,
@@ -150,6 +236,7 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
         )
         self._queues = Queues(read=asyncio.Queue(), write=asyncio.Queue())
         self._entry_lock = asyncio.Lock()
+        self._statistics = Statistics()
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -172,6 +259,8 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             device.dispatch_nowait(ATTR_CONNECTED, True)
 
         self.connected.set()
+        self.statistics.reset_transfer_statistics()
+        self.statistics.connected_since = datetime.now()
 
     async def _connection_close(self) -> None:
         """Close the connection if it is established."""
@@ -200,19 +289,27 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
         self, queues: Queues, reader: FrameReader, writer: FrameWriter
     ) -> None:
         """Handle frame reads and writes."""
+        statistics = self.statistics
         await self.connected.wait()
         while self.connected.is_set():
             try:
+                request = None
                 if not queues.write.empty():
-                    await writer.write(await queues.write.get())
+                    request = await queues.write.get()
+                    await writer.write(request)
                     queues.write.task_done()
 
                 if response := await reader.read():
                     queues.read.put_nowait(response)
 
+                statistics.update_transfer_statistics(request, response)
+
             except ProtocolError as e:
+                statistics.failed_frames += 1
                 _LOGGER.debug("Can't process received frame: %s", e)
             except (OSError, asyncio.TimeoutError):
+                statistics.connection_losses += 1
+                statistics.connection_loss_at = datetime.now()
                 self.create_task(self.connection_lost())
                 break
             except Exception:
@@ -239,8 +336,21 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
                 device.dispatch_nowait(ATTR_CONNECTED, True)
                 device.dispatch_nowait(ATTR_SETUP, True)
                 await self.dispatch(name, device)
+                self.statistics.devices.append(
+                    device_statistics := DeviceStatistics(
+                        name=name,
+                        connected_since=datetime.now(),
+                        last_seen=datetime.now(),
+                    )
+                )
+                device.subscribe(ATTR_REGDATA, device_statistics.update_last_seen)
 
         return self.data[name]
 
+    @property
+    def statistics(self) -> Statistics:
+        """Return the statistics."""
+        return self._statistics
+
 
-__all__ = ["Protocol", "DummyProtocol", "AsyncProtocol"]
+__all__ = ["Protocol", "DummyProtocol", "AsyncProtocol", "Statistics"]

{pyplumio-0.5.54.dist-info → pyplumio-0.5.56.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.54
+Version: 0.5.56
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License

{pyplumio-0.5.54.dist-info → pyplumio-0.5.56.dist-info}/RECORD

@@ -1,17 +1,17 @@
 pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=Kso5O0qgc2O4WADsLkE0mLHNOrYeVP6CbRg5BIXR8FM,706
+pyplumio/_version.py,sha256=AF48JunwQGeZYZUVpG4oP5XCtgX_ssZWD1yfHXBvb9I,706
 pyplumio/connection.py,sha256=u-iOzEUqoEEL4YLpLtzBWi5Qy8_RABgKD8DyXf-er-4,5892
 pyplumio/const.py,sha256=eoq-WNJ8TO3YlP7dC7KkVQRKGjt9FbRZ6M__s29vb1U,5659
 pyplumio/data_types.py,sha256=BTDxwErRo_odvFT5DNfIniNh8ZfyjRKEDaJmoEJqdEg,9426
 pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
 pyplumio/filters.py,sha256=QEtOptXym2Fb82cdPpS1dajkTpvYi3VuQaYoLl4CSQ4,15658
-pyplumio/protocol.py,sha256=DWM-yJnm2EQPLvGzXNlkQ0IpKQn44e-WkNB_DqZAag8,8313
+pyplumio/protocol.py,sha256=ndsdnd7juX-NlrBMIAhEkx8x5DNlh_Q4FZ4pzvbT1yQ,12276
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyplumio/stream.py,sha256=zFMKZ_GxsSGcaBTJigVM1CK3uGjlEJXgcvKqus8MDzk,7740
 pyplumio/utils.py,sha256=ktV8_Th2DiwQ0W6afOCau9kBJ8pOrqR-SM2Y2GRy-xE,1869
 pyplumio/devices/__init__.py,sha256=d0E5hTV7UPa8flq8TNlKf_jt4cOSbRigSE9jjDHrmDI,8302
-pyplumio/devices/ecomax.py,sha256=28Tr3WE8jI_zTYXYgSfR8nhppwzkQdmfAivt_iBUbTA,16057
+pyplumio/devices/ecomax.py,sha256=1QasnLFgNCplSoDXXe5wUr8JQjr6ChSEGijamXtJZVM,16356
 pyplumio/devices/ecoster.py,sha256=X46ky5XT8jHMFq9sBW0ve8ZI_tjItQDMt4moXsW-ogY,307
 pyplumio/devices/mixer.py,sha256=7WdUVgwO4VXmaPNzh3ZWpKr2ooRXWemz2KFHAw35_Rk,2731
 pyplumio/devices/thermostat.py,sha256=MHMKe45fQ7jKlhBVObJ7McbYQKuF6-LOKSHy-9VNsCU,2253
@@ -56,8 +56,8 @@ pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8p
 pyplumio/structures/temperatures.py,sha256=2VD3P_vwp9PEBkOn2-WhifOR8w-UYNq35aAxle0z2Vg,2831
 pyplumio/structures/thermostat_parameters.py,sha256=st3x3HkjQm3hqBrn_fpvPDQu8fuc-Sx33ONB19ViQak,3007
 pyplumio/structures/thermostat_sensors.py,sha256=rO9jTZWGQpThtJqVdbbv8sYMYHxJi4MfwZQza69L2zw,3399
-pyplumio-0.5.54.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.54.dist-info/METADATA,sha256=dy0asMgq9FuRsiENh0PctlZYWcagYIKalPTtlLjeT5o,5617
-pyplumio-0.5.54.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyplumio-0.5.54.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.54.dist-info/RECORD,,
+pyplumio-0.5.56.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.56.dist-info/METADATA,sha256=2YzNOAb-PMDVCsLFfR0VLgsPGnQWGzOXL6nzuCTncTk,5617
+pyplumio-0.5.56.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyplumio-0.5.56.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.56.dist-info/RECORD,,