pysmarlaapi 0.9.3__tar.gz → 0.10.0__tar.gz

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysmarlaapi
-Version: 0.9.3
+Version: 0.10.0
 Summary: Swing2Sleep Smarla API
 Author-email: Robin Lintermann <robin.lintermann@explicatis.com>
 Requires-Python: >=3.11

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/pysmarlaapi/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.9.3"
+__version__ = "0.10.0"
 
 from .classes import Connection
 from .federwiege import Federwiege

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/pysmarlaapi/connection_hub/__init__.py

@@ -9,11 +9,12 @@ from pysignalr.transport.abstract import ConnectionState
 from ..classes import Connection
 
 
-async def event_wait(event, timeout):
+async def event_wait(event, timeout) -> bool:
     try:
         await asyncio.wait_for(event.wait(), timeout)
     except asyncio.TimeoutError:
-        return
+        return False
+    return True
 
 
 # suppress warnings from pysignalr (to avoid missing client method warnings)
@@ -38,11 +39,13 @@ class ConnectionHub:
         event_loop: asyncio.AbstractEventLoop,
         connection: Connection,
         max_delay: int = 256,
+        forced_reconnect_interval: int = 86400,
     ):
         self.connection: Connection = connection
         self._loop = event_loop
         self._retry_delay = 1 # Initial connection retry delay
         self._max_delay = max_delay
+        self._forced_reconnect_interval = forced_reconnect_interval
 
         self.logger = logging.getLogger(f"{__package__}[{self.connection.token.serialNumber}]")
 
@@ -51,6 +54,10 @@ class ConnectionHub:
         self._running = False
         self._wake = asyncio.Event()
 
+        self._reconnect_future: asyncio.Future = None
+        self._reconnect_lock = asyncio.Lock()
+        self._reconnect_cancel_event = asyncio.Event()
+
         self.client = None
         self.setup()
 
@@ -85,9 +92,11 @@ class ConnectionHub:
     async def on_open_function(self):
         self._retry_delay = 1
         self.logger.info("Connection to server established")
+        await self.start_reconnect_job()
 
     async def on_close_function(self):
         self.logger.info("Connection to server closed")
+        await self.cancel_reconnect_job()
 
     async def on_error(self, message):
         self.logger.error("Connection error occurred: %s", str(message))
@@ -102,8 +111,8 @@ class ConnectionHub:
         if not self.running:
             return
         self._running = False
-        self.close_connection()
         self.wake_up()
+        asyncio.run_coroutine_threadsafe(self.close_connection(), self._loop)
 
     async def connection_watcher(self):
         while self.running:
@@ -115,7 +124,8 @@ class ConnectionHub:
 
             # Random backoff to avoid simultaneous connection attempts
             jitter = random.uniform(0, 0.5) * self._retry_delay
-            await event_wait(self._wake, self._retry_delay + jitter)
+            delay = self._retry_delay + jitter
+            await event_wait(self._wake, delay)
             self._wake.clear()
 
             # Double the delay for the next attempt
@@ -125,10 +135,32 @@ class ConnectionHub:
     def wake_up(self):
         self._wake.set()
 
-    def close_connection(self):
-        if not self.connected:
+    async def close_connection(self):
+        await self.cancel_reconnect_job()
+        await self.client._transport._ws.close()
+
+    async def start_reconnect_job(self):
+        async with self._reconnect_lock:
+            if self._reconnect_future and not self._reconnect_future.done():
+                return
+            self._reconnect_cancel_event.clear()
+            self._reconnect_future = asyncio.create_task(self.reconnect_job())
+
+    async def cancel_reconnect_job(self):
+        async with self._reconnect_lock:
+            if not self._reconnect_future or self._reconnect_future.done():
+                return
+            self._reconnect_cancel_event.set()
+            await self._reconnect_future
+
+    async def reconnect_job(self):
+        cancelled = await event_wait(self._reconnect_cancel_event, self._forced_reconnect_interval)
+        if cancelled:
             return
-        asyncio.run_coroutine_threadsafe(self.client._transport._ws.close(), self._loop)
+
+        # Close connection to trigger a reconnection
+        # Make sure that connection stays healthy
+        await self.client._transport._ws.close()
 
     async def refresh_token(self):
         await self.connection.refresh_token()

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/pysmarlaapi/federwiege/__init__.py

@@ -4,7 +4,8 @@ import threading
 from ..classes import Connection
 from ..connection_hub import ConnectionHub
 from .classes import Service
-from .services import AnalyserService, BabywiegeService, InfoService
+from .services import (AnalyserService, BabywiegeService, InfoService,
+                       SystemService)
 
 
 class Federwiege:
@@ -29,6 +30,7 @@ class Federwiege:
             "babywiege": BabywiegeService(self.hub),
             "analyser": AnalyserService(self.hub),
             "info": InfoService(self.hub),
+            "system": SystemService(self.hub),
         }
 
         self.registered = False

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/pysmarlaapi/federwiege/services/__init__.py

@@ -1,3 +1,4 @@
 from .analyser_service import AnalyserService
 from .babywiege_service import BabywiegeService
 from .info_service import InfoService
+from .system_service import SystemService

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/pysmarlaapi/federwiege/services/analyser_service.py

@@ -1,5 +1,6 @@
 from ...connection_hub import ConnectionHub
 from ..classes import Property, Service
+from ..types import SpringStatus
 
 
 class AnalyserService(Service):
@@ -9,6 +10,7 @@ class AnalyserService(Service):
         self.add_property("oscillation", OscillationProperty(hub))
         self.add_property("activity", ActivityProperty(hub))
         self.add_property("swing_count", SwingCountProperty(hub))
+        self.add_property("spring_status", SpringStatusProperty(hub))
 
 
 class OscillationProperty(Property[list[int]]):
@@ -60,3 +62,20 @@ class SwingCountProperty(Property[int]):
 
     def register(self):
         self.hub.client.on("GetSwingCountCallback", self.on_callback)
+
+
+class SpringStatusProperty(Property[SpringStatus]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners()
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__(hub)
+
+    def pull(self):
+        self.hub.send_serialized_data("GetSpringStatus")
+
+    def register(self):
+        self.hub.client.on("GetSpringStatusCallback", self.on_callback)

{pysmarlaapi-0.9.3 → pysmarlaapi-0.10.0}/pysmarlaapi/federwiege/services/info_service.py

@@ -8,6 +8,7 @@ class InfoService(Service):
         super().__init__()
         self.add_property("display_name", DisplayNameProperty(hub))
         self.add_property("version", VersionProperty(hub))
+        self.add_property("total_swing_time", TotalSwingTimeProperty(hub))
 
 
 class DisplayNameProperty(Property[str]):
@@ -42,3 +43,20 @@ class VersionProperty(Property[str]):
 
     def register(self):
         self.hub.client.on("GetVersionCallback", self.on_callback)
+
+
+class TotalSwingTimeProperty(Property[int]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners()
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__(hub)
+
+    def pull(self):
+        self.hub.send_serialized_data("GetTotalSwingTime")
+
+    def register(self):
+        self.hub.client.on("GetTotalSwingTimeCallback", self.on_callback)

pysmarlaapi-0.10.0/pysmarlaapi/federwiege/services/system_service.py

@@ -0,0 +1,65 @@
+from ...connection_hub import ConnectionHub
+from ..classes import Property, Service
+from ..types import SendDiagStatus, UpdateStatus
+
+
+class SystemService(Service):
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__()
+        self.add_property("firmware_update", FirmwareUpdateProperty(hub))
+        self.add_property("firmware_update_status", FirmwareUpdateStatusProperty(hub))
+        self.add_property("send_diagnostic_data", SendDiagnosticDataProperty(hub))
+        self.add_property("send_diagnostic_data_status", SendDiagnosticDataStatusProperty(hub))
+
+
+class FirmwareUpdateProperty(Property[int]):
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__(hub)
+
+    def push(self, value: int):
+        self.hub.send_serialized_data("SetFirmwareUpdate", value)
+
+
+class FirmwareUpdateStatusProperty(Property[UpdateStatus]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners()
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__(hub)
+
+    def pull(self):
+        self.hub.send_serialized_data("GetFirmwareUpdate")
+
+    def register(self):
+        self.hub.client.on("GetFirmwareUpdateCallback", self.on_callback)
+
+
+class SendDiagnosticDataProperty(Property[str]):
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__(hub)
+
+    def push(self, value: str):
+        self.hub.send_serialized_data("SetSendDiagnosticData", value)
+
+
+class SendDiagnosticDataStatusProperty(Property[SendDiagStatus]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners()
+
+    def __init__(self, hub: ConnectionHub):
+        super().__init__(hub)
+
+    def pull(self):
+        self.hub.send_serialized_data("GetSendDiagnosticData")
+
+    def register(self):
+        self.hub.client.on("GetSendDiagnosticDataCallback", self.on_callback)

pysmarlaapi-0.10.0/pysmarlaapi/federwiege/types/__init__.py

@@ -0,0 +1,3 @@
+from .send_diag_status import SendDiagStatus
+from .spring_status import SpringStatus
+from .update_status import UpdateStatus

pysmarlaapi-0.10.0/pysmarlaapi/federwiege/types/send_diag_status.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class SendDiagStatus(IntEnum):
+    IDLE = 0
+    GATHERING = 1
+    SENDING = 2
+    FAILED = 3

pysmarlaapi-0.10.0/pysmarlaapi/federwiege/types/spring_status.py

@@ -0,0 +1,10 @@
+from enum import IntEnum
+
+
+class SpringStatus(IntEnum):
+    UNKNOWN = 0
+    NORMAL = 1
+    CONSTELLATION_TOO_HIGH = 2
+    CONSTELLATION_TOO_LOW = 3
+    CONSTELLATION_CRITICAL_TOO_HIGH = 4
+    CONSTELLATION_CRITICAL_TOO_LOW = 5

pysmarlaapi-0.10.0/pysmarlaapi/federwiege/types/update_status.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class UpdateStatus(IntEnum):
+    IDLE = 0
+    DOWNLOADING = 1
+    INSTALLING = 2
+    FAILED = 3