ironflock 0.1.1__py3-none-any.whl → 1.0.5__py3-none-any.whl

ironflock/AutobahnConnection.py

@@ -9,8 +9,18 @@ try:
 except:
     raise Exception("Environment variable SWARM_KEY not set!")
 
-CB_REALM = "userapps"
-# CB_REALM = f"swarm{SWARM_KEY}"
+try:
+    APP_KEY = os.environ["APP_KEY"]
+except:
+    raise Exception("Environment variable APP_KEY not set!")
+
+try:
+    ENV = os.environ["ENV"].lower()
+except:
+    raise Exception("Environment variable ENV not set!")
+
+# CB_REALM = "userapps"
+CB_REALM = f"realm-{SWARM_KEY}-{APP_KEY}-{ENV}"
 
 DATAPODS_WS_URI = "wss://cbw.datapods.io/ws-ua-usr"
 STUDIO_WS_URI_OLD = "wss://cbw.record-evolution.com/ws-ua-usr"
@@ -69,7 +79,7 @@ class AppSession(ApplicationSession):
 def create_application_session(
     serial_number: str = None,
 ) -> Tuple[ApplicationSession, ApplicationRunner]:
-    """Creates an Autobahn ApplicationSession and ApplicationRunner, which connects to the RE Platform
+    """Creates an Autobahn ApplicationSession and ApplicationRunner, which connects to the IronFlock Platform
 
     Args:
         serial_number (str, optional): serial_number of device.
@@ -91,7 +101,7 @@ def create_application_session(
 
 
 def create_application_component(serial_number: str = None) -> Component:
-    """Creates an Autobahn Component, which connects to the RE Platform
+    """Creates an Autobahn Component, which connects to the IronFlock Platform
 
     Args:
         serial_number (str, optional): serial_number of device.

ironflock/__init__.py

@@ -7,4 +7,4 @@ from ironflock.ironflock import IronFlock
 
 __all__ = ["IronFlock", "create_application_component", "create_application_session"]
 
-__version__ = "0.0.19"
+__version__ = "1.0.5"

ironflock/ironflock.py

@@ -1,30 +1,29 @@
 import os
+import asyncio
 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.types import PublishOptions, RegisterOptions
 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.
+    """Conveniance class for easy-to-use message publishing in the IronFlock platform.
 
     Example:
 
-        rw = IronFlock()
-
         async def main():
             while True:
-                publication = await rw.publish("test.publish.pw", 1, "two", 3, foo="bar")
+                publication = await ironFlock.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()
+            ironflock = IronFlock(mainFunc=main)
+            ironFlock.run()
     """
 
     def __init__(self, serial_number: str = None, mainFunc=None) -> None:
@@ -36,6 +35,7 @@ class IronFlock:
         """
         self._serial_number = getSerialNumber(serial_number)
         self._device_name = os.environ.get("DEVICE_NAME")
+        self._device_key = os.environ.get("DEVICE_KEY")
         self._component = create_application_component(serial_number)
         self._session: ISession = None
         self.mainFunc = mainFunc
@@ -44,17 +44,22 @@ class IronFlock:
         async def onJoin(session, details):
             print("component joined")
             self._session = session
+            self._main_task = asyncio.create_task(mainFunc())
+
             if self.mainFunc: 
                 await self.mainFunc()
 
         @self._component.on_disconnect
-        def onDisconnect(*args, **kwargs):
-            print("component disconnected")
-            self._session = None
-
         @self._component.on_leave
-        def onLeave(*args, **kwargs):
+        async def onLeave(*args, **kwargs):
             print("component left")
+            if self._main_task:
+                self._main_task.cancel()
+                try:
+                    await self._main_task
+                except asyncio.CancelledError:
+                    pass
+                self._main_task = None
             self._session = None
 
     @property
@@ -76,7 +81,7 @@ class IronFlock:
         return self._session
 
     async def publish(self, topic: str, *args, **kwargs) -> Optional[Publication]:
-        """Publishes to the RE Platform Message Router
+        """Publishes to the IronFlock Platform Message Router
 
         Args:
             topic (str): The URI of the topic to publish to, e.g. "com.myapp.mytopic1"
@@ -88,6 +93,7 @@ class IronFlock:
 
         extra = {
             "DEVICE_SERIAL_NUMBER": self._serial_number,
+            "DEVICE_KEY": self._device_key,
             "DEVICE_NAME": self._device_name,
             "options": PublishOptions(acknowledge=True),
         }
@@ -102,6 +108,8 @@ class IronFlock:
         """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.
+            The location history will not be stored in the platform. 
+            If you need location history, then create a dedicated table for it.
         """
 
         payload = {
@@ -111,18 +119,43 @@ class IronFlock:
         
         extra = {
             "DEVICE_SERIAL_NUMBER": self._serial_number,
+            "DEVICE_KEY": self._device_key,
             "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 register_function(self, topic: str, func):
+        """Registers a function to be called when a message is received on the given topic.
+        
+        Args:
+            topic (str): The URI of the topic to register the function for, e.g. "example.mytopic1".
+            func (callable): The function to call when a message is received on the topic.
+        """
+        swarm_key = os.environ.get("SWARM_KEY")
+        app_key = os.environ.get("APP_KEY")
+        env_value = os.environ.get("ENV")
+        
+        topic = f"{swarm_key}.{self._device_key}.{app_key}.{env_value}.{topic}"
+        
+        if self._session is not None:
+            await self._session.register(topic, func, options=RegisterOptions(force_reregister=True))
+        else:
+            print("cannot register function, not connected")
 
     async def publish_to_table(
         self, tablename: str, *args, **kwargs
     ) -> Optional[Publication]:
-        """Publishes Data to a Table in the RE Platform
-
+        """Publishes Data to a Table in the IronFlock Platform. This is a conveniance function.
+            You can achieve the same results by simply publishing a payload to the topic
+            
+            [SWARM_KEY].[APP_KEY].[your_table_name]
+            
+            The SWARM_KEY and APP_KEY are provided as environment variables to the device container.
+            The also provided ENV variable holds either PROD or DEV to decide which topic to use, above.
+            This function automatically detects the environment and publishes to the correct table.
         Args:
             tablename (str): The table name of the table to publish to, e.g. "sensordata"
 
@@ -144,16 +177,7 @@ class IronFlock:
         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}"
+        topic = f"{swarm_key}.{app_key}.{tablename}"
 
         pub = await self.publish(topic, *args, **kwargs)
         return pub

ironflock-1.0.5.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: ironflock
+Version: 1.0.5
+Summary: SDK to integrate your IronFlock Industry 4 Apps with the IronFlock Data Infrastructure
+Home-page: https://github.com/RecordEvolution/ironflock-py
+Author: Record Evolution GmbH
+Author-email: marko.petzold@record-evolution.de
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: autobahn[asyncio,serialization]==22.3.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ironflock
+
+## About
+
+With this library you can publish data from your apps on your IoT edge hardware to the fleet data storage of the [IronFlock](https://studio.ironflock.com) devops platform.
+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.
+
+For more information on the IronFlock IoT Devops Platform for engineers and developers visit our [IronFlock](https://www.ironflock.com) home page.
+## Usage
+
+```python
+import asyncio
+from ironflock import IronFlock
+
+# create an IronFlock instance to connect to the IronFlock platform data infrastructure.
+# The IronFlock instance handles authentication when run on a device registered in IronFlock.
+ironflock = IronFlock()
+
+async def main():
+    while True:
+        # publish an event (if connection is not established the publish is skipped)
+        publication = await ironflock.publish("test.publish.com", {"temperature": 20})
+        print(publication)
+        await asyncio.sleep(3)
+
+
+if __name__ == "__main__":
+    ironflock = IronFlock(mainFunc=main)
+    ironflock.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](https://github.com/RecordEvolution/ironflock-py/tree/main/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
+make publish
+```
+
+Check the package at https://pypi.org/project/ironflock/.

ironflock-1.0.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+ironflock/AutobahnConnection.py,sha256=clwEsptqQFjDFn4dUGN4bQyb1cOnPmmNjetfTrRqckY,3687
+ironflock/__init__.py,sha256=J5w21EeWOBHuxr98nMVMXAASa0tYnKppMluxtKL_x4U,264
+ironflock/ironflock.py,sha256=7ugUzrt1yCG_hJAlUKiyMqALZzhrvokHBOgsPDpLxgU,6906
+ironflock-1.0.5.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
+ironflock-1.0.5.dist-info/METADATA,sha256=9htX7guGxMP0xAqdOg-uWuyy8riEEs37LrPvV1gygQY,2764
+ironflock-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ironflock-1.0.5.dist-info/top_level.txt,sha256=hmMdMPJuvnOTlFKYl1XQOn81vg1DE2LT7xrEXgyxcRA,10
+ironflock-1.0.5.dist-info/RECORD,,

{ironflock-0.1.1.dist-info → ironflock-1.0.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ironflock-0.1.1.dist-info/METADATA

@@ -1,80 +0,0 @@
-Metadata-Version: 2.1
-Name: ironflock
-Version: 0.1.1
-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.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-ironflock/AutobahnConnection.py,sha256=IX5VjUhRGq4-zo8cx2CH964pmoPH29sWc0eQAAG60gM,3438
-ironflock/__init__.py,sha256=LsyyAenv7GrvQSmPc3QJDu7_VsK7BDIvbwGC8ebEI9A,265
-ironflock/ironflock.py,sha256=I0T3NvY8kL7TzdjPdn7HfOxMDxsTF2qRhnklRU09dZ4,5385
-ironflock-0.1.1.dist-info/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
-ironflock-0.1.1.dist-info/METADATA,sha256=HRePXC8dtOLvc-5tkJ347ZJEpTO0__K1pFJp_PsdzaA,2295
-ironflock-0.1.1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-ironflock-0.1.1.dist-info/top_level.txt,sha256=hmMdMPJuvnOTlFKYl1XQOn81vg1DE2LT7xrEXgyxcRA,10
-ironflock-0.1.1.dist-info/RECORD,,