pysmarlaapi 0.1.0__py3-none-any.whl

pysmarlaapi/__init__.py

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

pysmarlaapi/classes/__init__.py

@@ -0,0 +1,2 @@
+from .auth_token import AuthToken
+from .connection import Connection

pysmarlaapi/classes/auth_token.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from typing import Self
+
+import jsonpickle
+
+
+@dataclass
+class AuthToken:
+    refreshToken: str
+    token: str
+    dateCreated: str
+    appIdentifier: str
+    serialNumber: str
+    appVersion: str
+    appCulture: str
+
+    @classmethod
+    def from_json(cls, value) -> Self:
+        value["py/object"] = "pysmarlaapi.classes.auth_token.AuthToken"
+        return jsonpickle.decode(str(value))
+
+    @classmethod
+    def from_string(cls, value) -> Self:
+        return AuthToken.from_json(jsonpickle.decode(value))
+
+    def get_string(self) -> str:
+        return jsonpickle.encode(self, unpicklable=False)

pysmarlaapi/classes/connection.py

@@ -0,0 +1,38 @@
+import aiohttp
+import jsonpickle
+
+from . import AuthToken
+
+
+class Connection:
+
+    def __init__(self, url: str, token: AuthToken = None, token_str=None, token_json=None):
+        self.url = url
+        if token is not None:
+            self.token = token
+        elif token_json is not None:
+            self.token = AuthToken.from_json(token_json)
+        elif token_str is not None:
+            self.token = AuthToken.from_string(token_str)
+        else:
+            self.token = None
+
+    async def get_token(self) -> AuthToken:
+        try:
+            async with aiohttp.ClientSession(self.url) as session:
+                async with session.post(
+                    "/api/AppParing/getToken",
+                    headers={"accept": "*/*", "Content-Type": "application/json"},
+                    data=jsonpickle.encode(self.token, unpicklable=False),
+                ) as response:
+                    if response.status != 200:
+                        return None
+                    json_body = await response.json()
+        except ValueError:
+            return None
+        try:
+            new_token = AuthToken.from_json(json_body)
+        except ValueError:
+            return None
+        self.token = new_token
+        return self.token

pysmarlaapi/connection_hub/__init__.py

@@ -0,0 +1,148 @@
+import asyncio
+import logging
+import random
+import uuid
+
+from pysignalr.client import SignalRClient
+from pysignalr.transport.abstract import ConnectionState
+
+from ..classes import Connection
+
+
+async def event_wait(event, timeout):
+    try:
+        await asyncio.wait_for(event.wait(), timeout)
+    except asyncio.TimeoutError:
+        return
+
+
+class ConnectionHub:
+    """SignalRCore Hub
+    Provides interface via websocket for the controller using the SignalRCore protocol.
+    """
+
+    @property
+    def running(self):
+        return self._running
+
+    @property
+    def connected(self):
+        return self.client._transport._state == ConnectionState.connected if self.client else False
+
+    def __init__(
+        self,
+        async_loop: asyncio.AbstractEventLoop,
+        connection: Connection,
+        interval: int = 60,
+        backoff: int = 300,
+    ):
+        self.connection: Connection = connection
+        self._loop: asyncio.AbstractEventLoop = async_loop
+        self._interval = interval
+        self._backoff = backoff
+
+        self.logger = logging.getLogger(f"{__package__}[{self.connection.token.serialNumber}]")
+
+        self.listeners = set()
+
+        self._running = False
+        self._wake = asyncio.Event()
+
+        self.client = None
+        self.setup()
+
+    async def notifycontrollerconnection(self, args):
+        value = args[0]
+        if value == "ControllerConnected":
+            await self.notify_listeners(1)
+        else:
+            await self.notify_listeners(0)
+
+    def setup(self):
+        self.client = SignalRClient(self.connection.url + "/MobileAppHub", retry_count=1)
+        self.client.on_open(self.on_open_function)
+        self.client.on_close(self.on_close_function)
+        self.client.on_error(self.on_error)
+        self.client.on("SetNotifyAppConnectionCallback", self.notifycontrollerconnection)
+
+    def add_listener(self, listener):
+        if self.running:
+            return
+        self.listeners.add(listener)
+
+    def remove_listener(self, listener):
+        if self.running:
+            return
+        self.listeners.remove(listener)
+
+    async def notify_listeners(self, value):
+        for listener in self.listeners:
+            await listener(value)
+
+    async def on_open_function(self):
+        self.logger.info("Connection to server established")
+
+    async def on_close_function(self):
+        self.logger.info("Connection to server closed")
+
+    async def on_error(self, message):
+        self.logger.error("Connection error occurred: " + str(message))
+
+    def start(self):
+        if self.running:
+            return
+        self._running = True
+        asyncio.run_coroutine_threadsafe(self.connection_watcher(), self._loop)
+
+    def stop(self):
+        if not self.running:
+            return
+        self._running = False
+        self.close_connection()
+        self.wake_up()
+
+    async def connection_watcher(self):
+        while self.running:
+            await self.refresh_token()
+            try:
+                await self.client.run()
+            except Exception as e:
+                self.logger.warning(f"Error during connection: {type(e).__name__}: {str(e)}")
+
+            # Random backoff to avoid simultaneous connection attempts
+            backoff = random.randint(0, self._backoff)
+            await event_wait(self._wake, self._interval + backoff)
+            self._wake.clear()
+
+    def wake_up(self):
+        self._wake.set()
+
+    def close_connection(self):
+        if not self.connected:
+            return
+        asyncio.run_coroutine_threadsafe(self.client._transport._ws.close(), self._loop)
+
+    async def refresh_token(self):
+        await self.connection.get_token()
+        auth_token = self.connection.token.token
+        self.client._transport._headers["Authorization"] = f"Bearer {auth_token}"
+        self.logger.info("Auth token refreshed")
+
+    def send_serialized_data(self, event, value=None):
+        serialized_result = {
+            "callIdentifier": {
+                "requestNonce": str(uuid.uuid4()),
+            },
+        }
+        if value is not None:
+            serialized_result["value"] = value
+
+        self.logger.debug(f"Sending data, Event: {event}, Payload: {str(serialized_result)}")
+
+        asyncio.run_coroutine_threadsafe(self.send_data(event, [serialized_result]), self._loop)
+
+    async def send_data(self, event, data):
+        try:
+            await self.client.send(event, data)
+        except Exception:
+            pass

pysmarlaapi/federwiege/__init__.py

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

pysmarlaapi/federwiege/classes/__init__.py

@@ -0,0 +1,2 @@
+from .property import Property
+from .service import Service

pysmarlaapi/federwiege/classes/property.py

@@ -0,0 +1,46 @@
+import asyncio
+from typing import Generic, TypeVar
+
+from ...connection_hub import ConnectionHub
+
+_VT = TypeVar("_VT")
+
+
+class Property(Generic[_VT]):
+
+    def __init__(self, connection_hub: ConnectionHub):
+        self.hub = connection_hub
+        self.value: _VT = None
+        self.listeners = set()
+        self.lock = asyncio.Lock()
+
+    async def add_listener(self, listener):
+        async with self.lock:
+            self.listeners.add(listener)
+
+    async def remove_listener(self, listener):
+        async with self.lock:
+            self.listeners.remove(listener)
+
+    async def notify_listeners(self, value):
+        async with self.lock:
+            for listener in self.listeners:
+                await listener(value)
+
+    def get(self) -> _VT:
+        return self.value
+
+    def set(self, new_value: _VT, push=True):
+        if push:
+            self.push(new_value)
+        else:
+            self.value = new_value
+
+    def push(self):
+        pass
+
+    def pull(self):
+        pass
+
+    def register(self):
+        pass

pysmarlaapi/federwiege/classes/service.py

@@ -0,0 +1,33 @@
+from ...connection_hub import ConnectionHub
+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
+        self.props: dict[str, Property] = {}
+
+    def add_property(self, key: str, prop: Property):
+        self.props[key] = prop
+
+    def get_properties(self):
+        return self.props
+
+    def get_property(self, key: str):
+        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):
+        for prop in self.props.values():
+            prop.pull()

pysmarlaapi/federwiege/services/analyser_service.py

@@ -0,0 +1,47 @@
+from ...connection_hub import ConnectionHub
+from ..classes import Property, Service
+
+
+class AnalyserService(Service):
+
+    def __init__(self, connection_hub: ConnectionHub):
+        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]]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners(value)
+
+    def __init__(self, parent: Service):
+        super().__init__(parent)
+        self.value = [0, 0]
+
+    def pull(self):
+        self.hub.send_serialized_data("GetOscillation")
+
+    def register(self):
+        self.hub.client.on("GetOscillationCallback", self.on_callback)
+
+
+class ActivityProperty(Property[int]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners(value)
+
+    def __init__(self, parent: Service):
+        super().__init__(parent)
+        self.value = 0
+
+    def pull(self):
+        self.hub.send_serialized_data("GetActivity")
+
+    def register(self):
+        self.hub.client.on("GetActivityCallback", self.on_callback)

pysmarlaapi/federwiege/services/babywiege_service.py

@@ -0,0 +1,75 @@
+from ...connection_hub import ConnectionHub
+from ..classes import Property, Service
+
+
+class BabywiegeService(Service):
+
+    def __init__(self, connection_hub: ConnectionHub):
+        super().__init__(connection_hub)
+        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]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners(value)
+
+    def __init__(self, parent: Service):
+        super().__init__(parent)
+        self.value = False
+
+    def pull(self):
+        self.hub.send_serialized_data("GetSwingActive")
+
+    def push(self, value):
+        self.hub.send_serialized_data("SetSwingActive", value)
+
+    def register(self):
+        self.hub.client.on("GetSwingActiveCallback", self.on_callback)
+
+
+class IntensityProperty(Property[int]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners(value)
+
+    def __init__(self, parent: Service):
+        super().__init__(parent)
+        self.value = 0
+
+    def pull(self):
+        self.hub.send_serialized_data("GetIntensity")
+
+    def push(self, value):
+        self.hub.send_serialized_data("SetIntensity", value)
+
+    def register(self):
+        self.hub.client.on("GetIntensityCallback", self.on_callback)
+
+
+class SmartModeProperty(Property[bool]):
+
+    async def on_callback(self, args):
+        value = args[0]["value"]
+        self.set(value, push=False)
+        await self.notify_listeners(value)
+
+    def __init__(self, parent: Service):
+        super().__init__(parent)
+        self.value = False
+
+    def pull(self):
+        self.hub.send_serialized_data("GetSmartMode")
+
+    def push(self, value):
+        self.hub.send_serialized_data("SetSmartMode", value)
+
+    def register(self):
+        self.hub.client.on("GetSmartModeCallback", self.on_callback)

pysmarlaapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.3
+Name: pysmarlaapi
+Version: 0.1.0
+Summary: Swing2Sleep Smarla API via websocket with signalr protocol
+Author-email: Robin Lintermann <robin.lintermann@explicatis.com>
+Requires-Python: >=3.11.9
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 1 - Planning
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: aiohttp~=3.11.11
+Requires-Dist: jsonpickle~=4.0.0
+Requires-Dist: pysignalr~=1.1.0
+
+# Federwiege Python API
+
+Swing2Sleep Smarla API via websocket with signalr protocol.
+
+See tests for example usage.
+
+## Development Setup
+
+- `pip3 install -r requirements_dev.txt`
+- `pre-commit install`
+
+## Publishing
+
+- Use flit to publish package to pypi
+

pysmarlaapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pysmarlaapi/__init__.py,sha256=znC1d_F9YF0NBjawoeGmtVz7GxsTaECIFihco71pctE,112
+pysmarlaapi/classes/__init__.py,sha256=4F4LRzLQtj6AmzrXn74iHEZl-YElpMkb7MhEGkab504,71
+pysmarlaapi/classes/auth_token.py,sha256=FgLkZ0xPETfh1ZMQfWhwW6tkPnqFYeHhDUBLBFbauwA,663
+pysmarlaapi/classes/connection.py,sha256=vNh9vG4xAewl2gmkducwSd3u7osjYw5gwtZTZ48rqVo,1291
+pysmarlaapi/connection_hub/__init__.py,sha256=U76wUkXHjAgzZNuJKS8ZFRwIskPIkCW1HdI1_SLlGs0,4620
+pysmarlaapi/federwiege/__init__.py,sha256=-zzqsip6li-QPsUJv-wEoqLpUzHHN9gbUYACRAc_wSg,114
+pysmarlaapi/federwiege/classes/__init__.py,sha256=1cCe3iToaNmbUfy_7PynoPenNHtVcKC03rFc4ADqnbE,62
+pysmarlaapi/federwiege/classes/property.py,sha256=YZnpw0cD2NUPnlWo6TBjOzNTWcSJG1tvArXs1dRT6dY,1084
+pysmarlaapi/federwiege/classes/service.py,sha256=wZcfq4xVXu_LKojcZALs63n5le9ekx0sEYT8nHKJKbU,865
+pysmarlaapi/federwiege/services/analyser_service.py,sha256=RoY5gv_DxUb9W9oucmPGJgOmoy9zn_uHmNyZX2P_wOY,1365
+pysmarlaapi/federwiege/services/babywiege_service.py,sha256=qHZjkQK7vmHK0vVmtXrdAsTh9vdAAbuwOQfKLF6ltyQ,2192
+pysmarlaapi-0.1.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+pysmarlaapi-0.1.0.dist-info/METADATA,sha256=W1W63qwrvPtAh-Rfw0LUuqF-Ch-h9i9TneuQdxbr8tQ,763
+pysmarlaapi-0.1.0.dist-info/RECORD,,

pysmarlaapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any