pysmarlaapi 0.1.0__tar.gz → 0.2.1__tar.gz

{pysmarlaapi-0.1.0 → pysmarlaapi-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pysmarlaapi
-Version: 0.1.0
+Version: 0.2.1
 Summary: Swing2Sleep Smarla API via websocket with signalr protocol
 Author-email: Robin Lintermann <robin.lintermann@explicatis.com>
 Requires-Python: >=3.11.9

pysmarlaapi-0.2.1/pysmarlaapi/__init__.py

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

{pysmarlaapi-0.1.0 → pysmarlaapi-0.2.1}/pysmarlaapi/connection_hub/__init__.py

@@ -31,13 +31,13 @@ class ConnectionHub:
 
     def __init__(
         self,
-        async_loop: asyncio.AbstractEventLoop,
+        event_loop: asyncio.AbstractEventLoop,
         connection: Connection,
         interval: int = 60,
         backoff: int = 300,
     ):
         self.connection: Connection = connection
-        self._loop: asyncio.AbstractEventLoop = async_loop
+        self._loop = event_loop
         self._interval = interval
         self._backoff = backoff
 
@@ -54,9 +54,9 @@ class ConnectionHub:
     async def notifycontrollerconnection(self, args):
         value = args[0]
         if value == "ControllerConnected":
-            await self.notify_listeners(1)
+            await self.notify_listeners(True)
         else:
-            await self.notify_listeners(0)
+            await self.notify_listeners(False)
 
     def setup(self):
         self.client = SignalRClient(self.connection.url + "/MobileAppHub", retry_count=1)

pysmarlaapi-0.2.1/pysmarlaapi/federwiege/__init__.py

@@ -0,0 +1,63 @@
+import asyncio
+import threading
+
+from ..classes import Connection
+from ..connection_hub import ConnectionHub
+from .classes import Service
+from .services import AnalyserService, BabywiegeService
+
+
+class Federwiege:
+
+    @property
+    def running(self):
+        return self.hub.running
+
+    @property
+    def connected(self):
+        return self.hub.connected
+
+    async def on_controller_connection_change(self, value):
+        self.available = value
+        if value:
+            self.sync()
+
+    def __init__(self, event_loop: asyncio.AbstractEventLoop, connection: Connection):
+        self.serial_number = connection.token.serialNumber
+        self.hub = ConnectionHub(event_loop, connection)
+        self.services: dict[str, Service] = {
+            "babywiege": BabywiegeService(self.hub),
+            "analyser": AnalyserService(self.hub),
+        }
+
+        self.registered = False
+        self._lock = threading.Lock()
+
+        self.available = False
+
+    def get_service(self, service):
+        if service not in self.services:
+            return None
+        return self.services[service]
+
+    def connect(self):
+        with self._lock:
+            if not self.registered:
+                return
+            self.hub.start()
+
+    def disconnect(self):
+        self.hub.stop()
+
+    def sync(self):
+        for service in self.services.values():
+            service.sync()
+
+    def register(self):
+        with self._lock:
+            if self.registered:
+                return
+            self.registered = True
+            self.hub.add_listener(self.on_controller_connection_change)
+            for service in self.services.values():
+                service.register()

{pysmarlaapi-0.1.0 → pysmarlaapi-0.2.1}/pysmarlaapi/federwiege/classes/service.py

@@ -4,10 +4,6 @@ from .property import Property
 
 class Service:
 
-    async def on_connection_change(self, value):
-        if value:
-            self.sync()
-
     def __init__(self, connection_hub: ConnectionHub):
         self.hub = connection_hub
         self.registered = False
@@ -20,12 +16,13 @@ class Service:
         return self.props
 
     def get_property(self, key: str):
+        if key not in self.props:
+            return None
         return self.props[key]
 
     def register(self):
         for prop in self.props.values():
             prop.register()
-        self.hub.add_listener(self.on_connection_change)
         self.registered = True
 
     def sync(self):

pysmarlaapi-0.2.1/pysmarlaapi/federwiege/services/__init__.py

@@ -0,0 +1,2 @@
+from .analyser_service import AnalyserService
+from .babywiege_service import BabywiegeService

{pysmarlaapi-0.1.0 → pysmarlaapi-0.2.1}/pysmarlaapi/federwiege/services/analyser_service.py

@@ -8,7 +8,6 @@ class AnalyserService(Service):
         super().__init__(connection_hub)
         self.add_property("oscillation", OscillationProperty(self.hub))
         self.add_property("activity", ActivityProperty(self.hub))
-        self.register()
 
 
 class OscillationProperty(Property[list[int, int]]):

{pysmarlaapi-0.1.0 → pysmarlaapi-0.2.1}/pysmarlaapi/federwiege/services/babywiege_service.py

@@ -9,7 +9,6 @@ class BabywiegeService(Service):
         self.add_property("swing_active", SwingActiveProperty(self.hub))
         self.add_property("intensity", IntensityProperty(self.hub))
         self.add_property("smartmode", SmartModeProperty(self.hub))
-        self.register()
 
 
 class SwingActiveProperty(Property[bool]):

{pysmarlaapi-0.1.0 → pysmarlaapi-0.2.1}/tests/test.py

@@ -7,8 +7,7 @@ import time
 sys.path.append("../")
 logging.basicConfig(level=20)
 
-from pysmarlaapi import Connection, ConnectionHub
-from pysmarlaapi.federwiege import AnalyserService, BabywiegeService
+from pysmarlaapi import Connection, Federwiege
 
 try:
     from config import AUTH_TOKEN_PERSONAL, HOST
@@ -21,21 +20,20 @@ async_thread = threading.Thread(target=loop.run_forever)
 
 connection = Connection(url=HOST, token_json=AUTH_TOKEN_PERSONAL)
 
-hub = ConnectionHub(loop, connection, interval=10, backoff=0)
-babywiege_svc = BabywiegeService(hub)
-analyser_svc = AnalyserService(hub)
+federwiege = Federwiege(loop, connection)
 
 
 def main():
     async_thread.start()
-    hub.start()
+    federwiege.register()
+    federwiege.connect()
 
-    while not hub.connected:
+    while not (federwiege.connected and federwiege.available):
         time.sleep(1)
 
-    swing_active_prop = babywiege_svc.get_property("swing_active")
-    intensity_prop = babywiege_svc.get_property("intensity")
-    oscillation_prop = analyser_svc.get_property("oscillation")
+    swing_active_prop = federwiege.get_service("babywiege").get_property("swing_active")
+    intensity_prop = federwiege.get_service("babywiege").get_property("intensity")
+    oscillation_prop = federwiege.get_service("analyser").get_property("oscillation")
 
     time.sleep(1)
 
@@ -75,5 +73,7 @@ if __name__ == "__main__":
         main()
     except BaseException:
         pass
-    hub.stop()
+    federwiege.disconnect()
+    while federwiege.connected:
+        time.sleep(1)
     loop.call_soon_threadsafe(loop.stop)

pysmarlaapi-0.1.0/pysmarlaapi/__init__.py

@@ -1,4 +0,0 @@
-__version__ = "0.1.0"
-
-from .classes import AuthToken, Connection
-from .connection_hub import ConnectionHub

pysmarlaapi-0.1.0/pysmarlaapi/federwiege/__init__.py

@@ -1,2 +0,0 @@
-from .services.analyser_service import AnalyserService
-from .services.babywiege_service import BabywiegeService