pysmarlaapi 0.1.0__tar.gz

pysmarlaapi-0.1.0/.gitignore

@@ -0,0 +1,132 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Ignore config file with secrets
+/config.py

pysmarlaapi-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,59 @@
+ci:
+  autoupdate_commit_msg: "chore: update pre-commit hooks"
+  autofix_commit_msg: "style: pre-commit fixes"
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v2.31.0
+    hooks:
+      - id: pyupgrade
+        args: [--py37-plus]
+
+  - repo: https://github.com/hadialqattan/pycln
+    rev: v1.2.5
+    hooks:
+      - id: pycln
+        args: [--config=pyproject.toml]
+        stages: [manual]
+
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.1.0
+    hooks:
+      - id: codespell
+
+  - repo: https://github.com/pre-commit/pygrep-hooks
+    rev: v1.9.0
+    hooks:
+      - id: python-check-blanket-noqa
+      - id: python-check-blanket-type-ignore
+      - id: python-no-log-warn
+      - id: python-no-eval
+      - id: python-use-type-annotations
+      - id: rst-backticks
+      - id: rst-directive-colons
+      - id: rst-inline-touching-normal
+
+  - repo: https://github.com/mgedmin/check-manifest
+    rev: "0.47"
+    hooks:
+      - id: check-manifest
+        stages: [manual]

pysmarlaapi-0.1.0/.pypirc

@@ -0,0 +1,10 @@
+[distutils]
+index-servers =
+    pypi
+    testpypi
+
+[pypi]
+repository = https://upload.pypi.org/legacy/
+
+[testpypi]
+repository = https://test.pypi.org/legacy/

pysmarlaapi-0.1.0/.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+    "version": "0.1.0",
+    "configurations": [
+        {
+            "name": "Python: Debug Tests",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "purpose": [
+                "debug-test"
+            ],
+            "console": "integratedTerminal",
+            "justMyCode": false,
+            "env": {
+                "PYTEST_ADDOPTS": "--no-cov -n0 --dist no"
+            }
+        }
+    ]
+}

pysmarlaapi-0.1.0/.vscode/settings.json

@@ -0,0 +1,29 @@
+{
+    "editor.formatOnSave": true,
+    "editor.formatOnPaste": true,
+    "files.trimTrailingWhitespace": true,
+    "files.autoSave": "onFocusChange",
+    "git.autofetch": true,
+    "[jsonc]": {
+        "editor.defaultFormatter": "vscode.json-language-features"
+    },
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    },
+    "python.defaultInterpreterPath": "/usr/local/bin/python",
+    "python.formatting.provider": "black",
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+    "pylint.args": [
+        "--rcfile=pyproject.toml"
+    ],
+    "black-formatter.args": [
+        "--config=pyproject.toml"
+    ],
+    "flake8.args": [
+        "--toml-config=pyproject.toml"
+    ],
+    "isort.args": [
+        "--settings-path=pyproject.toml"
+    ]
+}

pysmarlaapi-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,14 @@
+# 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/pyproject.toml

@@ -0,0 +1,210 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name =  "pysmarlaapi"
+authors = [
+    {name = "Robin Lintermann", email = "robin.lintermann@explicatis.com"},
+]
+dependencies = [
+    "aiohttp~=3.11.11",
+    "jsonpickle~=4.0.0",
+    "pysignalr~=1.1.0",
+]
+description = "Swing2Sleep Smarla API via websocket with signalr protocol"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11"
+]
+requires-python = ">=3.11.9"
+dynamic = ["version"]
+
+[tool.flit.module]
+name = "pysmarlaapi"
+
+[tool.black]
+line-length = 120
+fast = true
+
+[tool.flake8]
+max-line-length = 120
+select = "F,E,W,B,B901,B902,B903"
+exclude = [
+    ".eggs",
+    ".git",
+    ".tox",
+    "nssm",
+    "obj",
+    "out",
+    "packages",
+    "pywin32",
+    "tests",
+    "swagger_client"
+]
+ignore = [
+    "E722",
+    "B001",
+    "W503",
+    "E203"
+]
+
+[tool.pylint]
+extension-pkg-whitelist= [
+    "numpy",
+    "torch",
+    "cv2",
+    "pyodbc",
+    "pydantic",
+    "ciso8601",
+    "netcdf4",
+    "scipy"
+]
+ignore="CVS"
+ignore-patterns="test.*?py,conftest.py"
+init-hook='import sys; sys.setrecursionlimit(8 * sys.getrecursionlimit())'
+jobs=0
+limit-inference-results=100
+persistent="yes"
+suggestion-mode="yes"
+unsafe-load-any-extension="no"
+
+[tool.pylint.'MESSAGES CONTROL']
+enable="c-extension-no-member"
+
+[tool.pylint.'REPORTS']
+evaluation="10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)"
+output-format="text"
+reports="no"
+score="yes"
+
+[tool.pylint.'REFACTORING']
+max-nested-blocks=5
+never-returning-functions="sys.exit"
+
+[tool.pylint.'BASIC']
+argument-naming-style="snake_case"
+attr-naming-style="snake_case"
+bad-names= [
+    "foo",
+    "bar"
+]
+class-attribute-naming-style="any"
+class-naming-style="PascalCase"
+const-naming-style="UPPER_CASE"
+docstring-min-length=-1
+function-naming-style="snake_case"
+good-names= [
+    "i",
+    "j",
+    "k",
+    "ex",
+    "Run",
+    "_"
+]
+include-naming-hint="yes"
+inlinevar-naming-style="any"
+method-naming-style="snake_case"
+module-naming-style="any"
+no-docstring-rgx="^_"
+property-classes="abc.abstractproperty"
+variable-naming-style="snake_case"
+
+[tool.pylint.'FORMAT']
+ignore-long-lines="^\\s*(# )?.*['\"]?<?https?://\\S+>?"
+indent-after-paren=4
+indent-string='    '
+max-line-length=120
+max-module-lines=1000
+single-line-class-stmt="no"
+single-line-if-stmt="no"
+
+[tool.pylint.'LOGGING']
+logging-format-style="old"
+logging-modules="logging"
+
+[tool.pylint.'MISCELLANEOUS']
+notes= [
+    "FIXME",
+    "XXX",
+    "TODO"
+]
+
+[tool.pylint.'SIMILARITIES']
+ignore-comments="yes"
+ignore-docstrings="yes"
+ignore-imports="yes"
+min-similarity-lines=7
+
+[tool.pylint.'SPELLING']
+max-spelling-suggestions=4
+spelling-store-unknown-words="no"
+
+[tool.pylint.'STRING']
+check-str-concat-over-line-jumps="no"
+
+[tool.pylint.'TYPECHECK']
+contextmanager-decorators="contextlib.contextmanager"
+generated-members="numpy.*,np.*,pyspark.sql.functions,collect_list"
+ignore-mixin-members="yes"
+ignore-none="yes"
+ignore-on-opaque-inference="yes"
+ignored-classes="optparse.Values,thread._local,_thread._local,numpy,torch,swagger_client"
+ignored-modules="numpy,torch,swagger_client,netCDF4,scipy"
+missing-member-hint="yes"
+missing-member-hint-distance=1
+missing-member-max-choices=1
+
+[tool.pylint.'VARIABLES']
+additional-builtins="dbutils"
+allow-global-unused-variables="yes"
+callbacks= [
+    "cb_",
+    "_cb"
+]
+dummy-variables-rgx="_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_"
+ignored-argument-names="_.*|^ignored_|^unused_"
+init-import="no"
+redefining-builtins-modules="six.moves,past.builtins,future.builtins,builtins,io"
+
+[tool.pylint.'CLASSES']
+defining-attr-methods= [
+    "__init__",
+    "__new__",
+    "setUp",
+    "__post_init__"
+]
+exclude-protected= [
+    "_asdict",
+    "_fields",
+    "_replace",
+    "_source",
+    "_make"
+]
+valid-classmethod-first-arg="cls"
+valid-metaclass-classmethod-first-arg="cls"
+
+[tool.pylint.'DESIGN']
+max-args=5
+max-attributes=7
+max-bool-expr=5
+max-branches=12
+max-locals=15
+max-parents=7
+max-public-methods=20
+max-returns=6
+max-statements=50
+min-public-methods=2
+
+[tool.pylint.'IMPORTS']
+allow-wildcard-with-all="no"
+analyse-fallback-blocks="no"
+deprecated-modules="optparse,tkinter.tix"
+
+[tool.pylint.'EXCEPTIONS']
+overgeneral-exceptions= [
+    "BaseException",
+    "Exception"
+]

pysmarlaapi-0.1.0/pysmarlaapi/__init__.py

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

pysmarlaapi-0.1.0/pysmarlaapi/classes/__init__.py

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

pysmarlaapi-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/pysmarlaapi/federwiege/__init__.py

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

pysmarlaapi-0.1.0/pysmarlaapi/federwiege/classes/__init__.py

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

pysmarlaapi-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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/requirements.txt

@@ -0,0 +1,3 @@
+aiohttp==3.11.11
+jsonpickle==4.0.0
+pysignalr==1.1.0

pysmarlaapi-0.1.0/requirements_dev.txt

@@ -0,0 +1,5 @@
+aiohttp==3.11.11
+flit==3.10.1
+jsonpickle==4.0.0
+pre-commit==4.0.1
+pysignalr==1.1.0

pysmarlaapi-0.1.0/tests/test.py

@@ -0,0 +1,79 @@
+import asyncio
+import logging
+import sys
+import threading
+import time
+
+sys.path.append("../")
+logging.basicConfig(level=20)
+
+from pysmarlaapi import Connection, ConnectionHub
+from pysmarlaapi.federwiege import AnalyserService, BabywiegeService
+
+try:
+    from config import AUTH_TOKEN_PERSONAL, HOST
+except ImportError:
+    print("config.py or mandatory variables missing, please add in root folder...")
+    exit()
+
+loop = asyncio.get_event_loop()
+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)
+
+
+def main():
+    async_thread.start()
+    hub.start()
+
+    while not hub.connected:
+        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")
+
+    time.sleep(1)
+
+    value = swing_active_prop.get()
+    print(f"Swing Active: {value}")
+    intensity = intensity_prop.get()
+    print(f"Intensity: {intensity}%")
+    oscillation = oscillation_prop.get()
+    print(f"Amplitude: {oscillation[0]}mm Period: {oscillation[1]}ms")
+
+    swing_active_prop.set(True)
+    intensity_prop.set(60)
+
+    time.sleep(1)
+
+    value = swing_active_prop.get()
+    print(f"Swing Active: {value}")
+    intensity = intensity_prop.get()
+    print(f"Intensity: {intensity}%")
+    oscillation = oscillation_prop.get()
+    print(f"Amplitude: {oscillation[0]}mm Period: {oscillation[1]}ms")
+
+    time.sleep(1)
+
+    while True:
+        value = swing_active_prop.get()
+        print(f"Swing Active: {value}")
+        intensity = intensity_prop.get()
+        print(f"Intensity: {intensity}%")
+        oscillation = oscillation_prop.get()
+        print(f"Amplitude: {oscillation[0]}mm Period: {oscillation[1]}ms")
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BaseException:
+        pass
+    hub.stop()
+    loop.call_soon_threadsafe(loop.stop)