ironflock 0.1.0__tar.gz

ironflock-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Record Evolution
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ironflock-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include MANIFEST.in
+include setup.py
+include *.cfg
+include *.ini
+include *.txt
+include requirements.txt

ironflock-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: ironflock
+Version: 0.1.0
+Summary: Publishing data to a IronFlock Fleet Storage
+Home-page: https://github.com/RecordEvolution/ironflock-python
+Author: Record Evolution GmbH
+Author-email: marko.petzold@record-evolution.de
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: autobahn[asyncio,compression,serialization]==22.3.2
+
+# ironflock
+
+## About
+
+With this library you can publishing data to IronFlock fleet storage. When this library is used on a certain device the library automatically uses the private messaging realm (Unified Name Space) of the device's fleet and the data is collected in the respective fleet database.
+
+So if you use the library in your app, the data collection will always be private to the app user's fleet.
+
+## Usage
+
+```python
+import asyncio
+from ironflock import IronFlock
+
+# create a ironflock instance, which auto connects to the IronFlock Platform
+# the ironflock instance handles authentication and reconnects when the connection is lost
+rw = IronFlock()
+
+async def main():
+    while True:
+        # publish an event (if connection is not established the publish is skipped)
+        publication = await rw.publish("test.publish.com", {"temperature": 20})
+        print(publication)
+        await asyncio.sleep(3)
+
+
+if __name__ == "__main__":
+    # run the main coroutine
+    asyncio.get_event_loop().create_task(main())
+    # run the ironflock component
+    rw.run()
+```
+
+## Options
+
+The `IronFlock` `__init__` function can be configured with the following options:
+
+```ts
+{
+    serial_number: string;
+}
+```
+
+**serial_number**: Used to set the serial_number of the device if the `DEVICE_SERIAL_NUMBER` environment variable does not exist. It can also be used if the user wishes to authenticate as another device.
+
+## Advanced Usage
+
+If you need more control, e.g. acting on lifecycle events (`onJoin`, `onLeave`) take a look at
+the [examples](./examples/) folder.
+
+
+## Development
+
+Install the necessary components if you don't have them already:
+
+```shell
+pip install --upgrade setuptools wheel twine
+```
+
+Build and publish a new pypi package:
+
+```shell
+python setup.py sdist bdist_wheel
+twine upload dist/*
+```
+
+Check the package at https://pypi.org/project/ironflock/.

ironflock-0.1.0/README.md

@@ -0,0 +1,67 @@
+# ironflock
+
+## About
+
+With this library you can publishing data to IronFlock fleet storage. When this library is used on a certain device the library automatically uses the private messaging realm (Unified Name Space) of the device's fleet and the data is collected in the respective fleet database.
+
+So if you use the library in your app, the data collection will always be private to the app user's fleet.
+
+## Usage
+
+```python
+import asyncio
+from ironflock import IronFlock
+
+# create a ironflock instance, which auto connects to the IronFlock Platform
+# the ironflock instance handles authentication and reconnects when the connection is lost
+rw = IronFlock()
+
+async def main():
+    while True:
+        # publish an event (if connection is not established the publish is skipped)
+        publication = await rw.publish("test.publish.com", {"temperature": 20})
+        print(publication)
+        await asyncio.sleep(3)
+
+
+if __name__ == "__main__":
+    # run the main coroutine
+    asyncio.get_event_loop().create_task(main())
+    # run the ironflock component
+    rw.run()
+```
+
+## Options
+
+The `IronFlock` `__init__` function can be configured with the following options:
+
+```ts
+{
+    serial_number: string;
+}
+```
+
+**serial_number**: Used to set the serial_number of the device if the `DEVICE_SERIAL_NUMBER` environment variable does not exist. It can also be used if the user wishes to authenticate as another device.
+
+## Advanced Usage
+
+If you need more control, e.g. acting on lifecycle events (`onJoin`, `onLeave`) take a look at
+the [examples](./examples/) folder.
+
+
+## Development
+
+Install the necessary components if you don't have them already:
+
+```shell
+pip install --upgrade setuptools wheel twine
+```
+
+Build and publish a new pypi package:
+
+```shell
+python setup.py sdist bdist_wheel
+twine upload dist/*
+```
+
+Check the package at https://pypi.org/project/ironflock/.

ironflock-0.1.0/ironflock/AutobahnConnection.py

@@ -0,0 +1,115 @@
+import os
+from typing import Tuple
+from autobahn.asyncio.component import Component
+from autobahn.asyncio.wamp import ApplicationSession, ApplicationRunner
+from autobahn.wamp import auth
+
+try:
+    SWARM_KEY = os.environ["SWARM_KEY"]
+except:
+    raise Exception("Environment variable SWARM_KEY not set!")
+
+CB_REALM = "userapps"
+# CB_REALM = f"swarm{SWARM_KEY}"
+
+DATAPODS_WS_URI = "wss://cbw.datapods.io/ws-ua-usr"
+STUDIO_WS_URI_OLD = "wss://cbw.record-evolution.com/ws-ua-usr"
+STUDIO_WS_URI = "wss://cbw.ironflock.com/ws-ua-usr"
+LOCALHOST_WS_URI = "ws://localhost:8080/ws-ua-usr"
+
+socketURIMap = {
+    "https://studio.datapods.io": DATAPODS_WS_URI,
+    "https://studio.record-evolution.com": STUDIO_WS_URI_OLD,
+    "https://studio.ironflock.com": STUDIO_WS_URI,
+    "http://localhost:8085": LOCALHOST_WS_URI,
+}
+
+
+def getWebSocketURI():
+    reswarm_url = os.environ.get("RESWARM_URL")
+    if not reswarm_url:
+        return STUDIO_WS_URI
+    return socketURIMap.get(reswarm_url)
+
+
+def getSerialNumber(serial_number: str = None) -> str:
+    if serial_number is None:
+        s_num = os.environ.get("DEVICE_SERIAL_NUMBER")
+        if s_num is None:
+            raise Exception("ENV Variable 'DEVICE_SERIAL_NUMBER' is not set!")
+    else:
+        s_num = serial_number
+    return s_num
+
+
+class AppSession(ApplicationSession):
+    serial_number: str = None
+
+    def onConnect(self):
+        print('onConnect called')
+        if self.serial_number is None:
+            raise Exception("serial_number missing on AppSession")
+
+        self.join(CB_REALM, ["wampcra"], self.serial_number)
+
+    def onChallenge(self, challenge):
+        print('challenge requested for {}'.format(challenge.method))
+        if challenge.method == "wampcra":
+            if self.serial_number is None:
+                raise Exception("serial_number missing on AppSession")
+
+            signature = auth.compute_wcs(
+                self.serial_number, challenge.extra["challenge"]
+            )
+            return signature
+
+        raise Exception("Invalid authmethod {}".format(challenge.method))
+
+
+def create_application_session(
+    serial_number: str = None,
+) -> Tuple[ApplicationSession, ApplicationRunner]:
+    """Creates an Autobahn ApplicationSession and ApplicationRunner, which connects to the RE Platform
+
+    Args:
+        serial_number (str, optional): serial_number of device.
+        Defaults to None, in which case the environment variable DEVICE_SERIAL_NUMBER is used.
+
+    Returns:
+        Tuple[ApplicationSession, ApplicationRunner]
+    """
+    AppSession.serial_number = getSerialNumber(serial_number)
+
+    runner = ApplicationRunner(
+        url=getWebSocketURI(),
+        realm=CB_REALM,
+    )
+
+    print('Application runner created')
+
+    return AppSession, runner
+
+
+def create_application_component(serial_number: str = None) -> Component:
+    """Creates an Autobahn Component, which connects to the RE Platform
+
+    Args:
+        serial_number (str, optional): serial_number of device.
+        Defaults to None, in which case the environment variable DEVICE_SERIAL_NUMBER is used.
+
+    Returns:
+        Component
+    """
+    appSession, _ = create_application_session(serial_number)
+
+    comp = Component(
+        transports=[{
+            "url": getWebSocketURI(),
+            "serializers": ['msgpack'],
+            }],
+        realm=CB_REALM,
+        session_factory=appSession,
+    )
+    print('WAMP Component created')
+
+    return comp

ironflock-0.1.0/ironflock/__init__.py

@@ -0,0 +1,10 @@
+from ironflock.AutobahnConnection import (
+    create_application_component,
+    create_application_session,
+)
+
+from ironflock.ironflock import IronFlock
+
+__all__ = ["IronFlock", "create_application_component", "create_application_session"]
+
+__version__ = "0.0.19"

ironflock-0.1.0/ironflock/ironflock.py

@@ -0,0 +1,166 @@
+import os
+from typing import Optional
+from autobahn.asyncio.component import Component, run
+from autobahn.wamp.interfaces import ISession
+from autobahn.wamp.types import PublishOptions
+from autobahn.wamp.request import Publication
+
+from ironflock.AutobahnConnection import getSerialNumber, create_application_component
+
+
+class IronFlock:
+    """Convenience class for easy to use message publishing to the RE platform.
+
+    Example:
+
+        rw = IronFlock()
+
+        async def main():
+            while True:
+                publication = await rw.publish("test.publish.pw", 1, "two", 3, foo="bar")
+                print(publication)
+                await asyncio.sleep(3)
+
+
+        if __name__ == "__main__":
+            asyncio.get_event_loop().create_task(main())
+            rw.run()
+    """
+
+    def __init__(self, serial_number: str = None, mainFunc=None) -> None:
+        """Creates IronFlock Instance
+
+        Args:
+            serial_number (str, optional): serial_number of device.
+            Defaults to None, in which case the environment variable DEVICE_SERIAL_NUMBER is used.
+        """
+        self._serial_number = getSerialNumber(serial_number)
+        self._device_name = os.environ.get("DEVICE_NAME")
+        self._component = create_application_component(serial_number)
+        self._session: ISession = None
+        self.mainFunc = mainFunc
+
+        @self._component.on_join
+        async def onJoin(session, details):
+            print("component joined")
+            self._session = session
+            if self.mainFunc: 
+                await self.mainFunc(session)
+
+        @self._component.on_disconnect
+        def onDisconnect(*args, **kwargs):
+            print("component disconnected")
+            self._session = None
+
+        @self._component.on_leave
+        def onLeave(*args, **kwargs):
+            print("component left")
+            self._session = None
+
+    @property
+    def component(self) -> Component:
+        """The Autobahn Component
+
+        Returns:
+            Component
+        """
+        return self._component
+
+    @property
+    def session(self) -> Optional[ISession]:
+        """The Autobahn Session
+
+        Returns:
+            Optional[ISession]
+        """
+        return self._session
+
+    async def publish(self, topic: str, *args, **kwargs) -> Optional[Publication]:
+        """Publishes to the RE Platform Message Router
+
+        Args:
+            topic (str): The URI of the topic to publish to, e.g. "com.myapp.mytopic1"
+
+        Returns:
+            Optional[Publication]: Object representing a publication
+            (feedback from publishing an event when doing an acknowledged publish)
+        """
+
+        extra = {
+            "DEVICE_SERIAL_NUMBER": self._serial_number,
+            "DEVICE_NAME": self._device_name,
+            "options": PublishOptions(acknowledge=True),
+        }
+
+        if self._session is not None:
+            pub = await self._session.publish(topic, *args, **kwargs, **extra)
+            return pub
+        else:
+            print("cannot publish, not connected")
+            
+    async def set_device_location(self, long: float, lat: float):
+        """Update the location of the device registered in the platform
+            This will update the device's location in the master data of the platform.
+            The maps in the device or group overviews will reflect the new device location in realtime.
+        """
+
+        payload = {
+            "long": long,
+            "lat": lat
+        }
+        
+        extra = {
+            "DEVICE_SERIAL_NUMBER": self._serial_number,
+            "DEVICE_NAME": self._device_name
+        }
+        
+        if hasattr(self, "_session") and hasattr(self._session, "call"):
+            res = await self._session.call('ironflock.location_service.update', payload, **extra)
+        return res
+
+    async def publish_to_table(
+        self, tablename: str, *args, **kwargs
+    ) -> Optional[Publication]:
+        """Publishes Data to a Table in the RE Platform
+
+        Args:
+            tablename (str): The table name of the table to publish to, e.g. "sensordata"
+
+        Returns:
+            Optional[Publication]: Object representing a publication
+            (feedback from publishing an event when doing an acknowledged publish)
+        """
+
+        if not tablename:
+            raise Exception("Tablename must not be None or empty string!")
+
+        swarm_key = os.environ.get("SWARM_KEY")
+        app_key = os.environ.get("APP_KEY")
+        env_value = os.environ.get("ENV")
+
+        if swarm_key is None:
+            raise Exception("Environment variable SWARM_KEY not set!")
+
+        if app_key is None:
+            raise Exception("Environment variable APP_KEY not set!")
+
+        if env_value is None:
+            raise Exception("Environment variable ENV not set!")
+
+        if not env_value in ["DEV", "PROD"]:
+            raise Exception("Environment variable ENV must be 'PROD' or 'DEV'!")
+
+        if env_value == "PROD":
+            topic = f"{swarm_key}.{app_key}.{tablename}"
+        else:
+            topic = f"dev.{swarm_key}.{app_key}.{tablename}"
+
+        pub = await self.publish(topic, *args, **kwargs)
+        return pub
+
+    def run(self, wait=True):
+        """Runs the Component in the asyncio event loop."""
+        if wait:
+            run([self._component])
+        else:
+            return self._component.start()

ironflock-0.1.0/ironflock.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: ironflock
+Version: 0.1.0
+Summary: Publishing data to a IronFlock Fleet Storage
+Home-page: https://github.com/RecordEvolution/ironflock-python
+Author: Record Evolution GmbH
+Author-email: marko.petzold@record-evolution.de
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: autobahn[asyncio,compression,serialization]==22.3.2
+
+# ironflock
+
+## About
+
+With this library you can publishing data to IronFlock fleet storage. When this library is used on a certain device the library automatically uses the private messaging realm (Unified Name Space) of the device's fleet and the data is collected in the respective fleet database.
+
+So if you use the library in your app, the data collection will always be private to the app user's fleet.
+
+## Usage
+
+```python
+import asyncio
+from ironflock import IronFlock
+
+# create a ironflock instance, which auto connects to the IronFlock Platform
+# the ironflock instance handles authentication and reconnects when the connection is lost
+rw = IronFlock()
+
+async def main():
+    while True:
+        # publish an event (if connection is not established the publish is skipped)
+        publication = await rw.publish("test.publish.com", {"temperature": 20})
+        print(publication)
+        await asyncio.sleep(3)
+
+
+if __name__ == "__main__":
+    # run the main coroutine
+    asyncio.get_event_loop().create_task(main())
+    # run the ironflock component
+    rw.run()
+```
+
+## Options
+
+The `IronFlock` `__init__` function can be configured with the following options:
+
+```ts
+{
+    serial_number: string;
+}
+```
+
+**serial_number**: Used to set the serial_number of the device if the `DEVICE_SERIAL_NUMBER` environment variable does not exist. It can also be used if the user wishes to authenticate as another device.
+
+## Advanced Usage
+
+If you need more control, e.g. acting on lifecycle events (`onJoin`, `onLeave`) take a look at
+the [examples](./examples/) folder.
+
+
+## Development
+
+Install the necessary components if you don't have them already:
+
+```shell
+pip install --upgrade setuptools wheel twine
+```
+
+Build and publish a new pypi package:
+
+```shell
+python setup.py sdist bdist_wheel
+twine upload dist/*
+```
+
+Check the package at https://pypi.org/project/ironflock/.

ironflock-0.1.0/ironflock.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+ironflock/AutobahnConnection.py
+ironflock/__init__.py
+ironflock/ironflock.py
+ironflock.egg-info/PKG-INFO
+ironflock.egg-info/SOURCES.txt
+ironflock.egg-info/dependency_links.txt
+ironflock.egg-info/requires.txt
+ironflock.egg-info/top_level.txt

ironflock-0.1.0/ironflock.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ironflock-0.1.0/ironflock.egg-info/requires.txt

@@ -0,0 +1 @@
+autobahn[asyncio,compression,serialization]==22.3.2

ironflock-0.1.0/ironflock.egg-info/top_level.txt

@@ -0,0 +1 @@
+ironflock

ironflock-0.1.0/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

ironflock-0.1.0/requirements.txt

@@ -0,0 +1 @@
+autobahn[asyncio, serialization, compression]==22.3.2

ironflock-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ironflock-0.1.0/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+requirements = []
+with open("requirements.txt", "r") as fh:
+    for line in fh:
+        requirements.append(line.strip())
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="ironflock",
+    version="0.1.0",
+    description="Publishing data to a IronFlock Fleet Storage",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/RecordEvolution/ironflock-python",
+    author="Record Evolution GmbH",
+    author_email="marko.petzold@record-evolution.de",
+    packages=find_packages(),
+    license="MIT",
+    python_requires=">=3.6",
+    install_requires=requirements,
+    classifiers=[],
+)