pysmarlaapi 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

pysmarlaapi/__init__.py

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

pysmarlaapi/classes/__init__.py

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

pysmarlaapi/classes/auth_token.py

@@ -1,36 +1,37 @@
-import base64
-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))
-
-    @classmethod
-    def from_base64(cls, value) -> Self:
-        token = base64.b64decode(value.encode()).decode()
-        return AuthToken.from_string(token)
-
-    def get_string(self) -> str:
-        return jsonpickle.encode(self, unpicklable=False)
-
-    def get_base64(self) -> str:
-        return base64.b64encode(self.get_string().encode()).decode()
+import base64
+import json
+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: dict) -> Self:
+        value["py/object"] = "pysmarlaapi.classes.auth_token.AuthToken"
+        return jsonpickle.decode(json.dumps(value))
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        return AuthToken.from_json(json.loads(value))
+
+    @classmethod
+    def from_base64(cls, value: str) -> Self:
+        token = base64.b64decode(value.encode()).decode()
+        return AuthToken.from_string(token)
+
+    def get_string(self) -> str:
+        return jsonpickle.encode(self, unpicklable=False)
+
+    def get_base64(self) -> str:
+        return base64.b64encode(self.get_string().encode()).decode()

pysmarlaapi/classes/connection.py

@@ -1,40 +1,41 @@
-import aiohttp
-import jsonpickle
-
-from . import AuthToken
-
-
-class Connection:
-
-    def __init__(self, url: str, token: AuthToken = None, token_str=None, token_json=None, token_b64=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)
-        elif token_b64 is not None:
-            self.token = AuthToken.from_base64(token_b64)
-        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
+import aiohttp
+import jsonpickle
+
+from . import AuthToken
+
+
+class Connection:
+
+    def __init__(self, url: str, token: AuthToken = None, token_str=None, token_json=None, token_b64=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)
+        elif token_b64 is not None:
+            self.token = AuthToken.from_base64(token_b64)
+        else:
+            self.token = None
+
+    def get_token(self) -> str:
+        return self.token.token
+
+    async def refresh_token(self) -> bool:
+        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 False
+                json_body = await response.json()
+
+        try:
+            self.token = AuthToken.from_json(json_body)
+        except ValueError:
+            return False
+
+        return True

pysmarlaapi/connection_hub/__init__.py

@@ -1,148 +1,147 @@
-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,
-        event_loop: asyncio.AbstractEventLoop,
-        connection: Connection,
-        interval: int = 60,
-        backoff: int = 300,
-    ):
-        self.connection: Connection = connection
-        self._loop = event_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(True)
-        else:
-            await self.notify_listeners(False)
-
-    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
+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,
+        event_loop: asyncio.AbstractEventLoop,
+        connection: Connection,
+        interval: int = 60,
+        backoff: int = 300,
+    ):
+        self.connection: Connection = connection
+        self._loop = event_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(True)
+        else:
+            await self.notify_listeners(False)
+
+    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.refresh_token()
+        self.client._transport._headers["Authorization"] = f"Bearer {self.connection.get_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.async_send_data(event, [serialized_result]), self._loop)
+
+    async def async_send_data(self, event, data):
+        try:
+            await self.client.send(event, data)
+        except Exception:
+            pass

pysmarlaapi/federwiege/__init__.py

@@ -1,64 +1,64 @@
-import asyncio
-import threading
-
-from ..classes import Connection
-from ..connection_hub import ConnectionHub
-from .classes import Service
-from .services import AnalyserService, BabywiegeService, InfoService
-
-
-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),
-            "info": InfoService(self.hub),
-        }
-
-        self.registered = False
-        self._lock = threading.Lock()
-
-        self.available = False
-
-    def get_service(self, service: str):
-        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()
+import asyncio
+import threading
+
+from ..classes import Connection
+from ..connection_hub import ConnectionHub
+from .classes import Service
+from .services import AnalyserService, BabywiegeService, InfoService
+
+
+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),
+            "info": InfoService(self.hub),
+        }
+
+        self.registered = False
+        self._lock = threading.Lock()
+
+        self.available = False
+
+    def get_service(self, service: str):
+        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/federwiege/classes/__init__.py

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