ironflock 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

ironflock/CrossbarConnection.py

@@ -0,0 +1,343 @@
+import asyncio
+import time
+import os
+from typing import Optional, List, Dict, Any, Callable
+from autobahn.asyncio.wamp import ApplicationSession
+from autobahn.asyncio.component import Component
+from autobahn.wamp import auth
+from enum import Enum
+
+class Stage(Enum):
+    """Stage enumeration for different deployment environments"""
+    DEVELOPMENT = "DEV"
+    PRODUCTION = "PROD"
+
+def getSerialNumber(serial_number: str = None) -> str:
+    """Get device serial number from parameter or environment variable"""
+    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
+
+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:8086": LOCALHOST_WS_URI,
+    "http://host.docker.internal:8086": LOCALHOST_WS_URI
+}
+
+class CrossbarConnection:
+    """
+    Python version of the TypeScript CrossbarConnection class.
+    Manages WAMP connections with automatic reconnection, subscription management, and session handling.
+    """
+    
+    def __init__(self):
+        self.session: Optional[ApplicationSession] = None
+        self.component: Optional[Component] = None
+        self.connection_options: Optional[Dict[str, Any]] = None
+        self.subscriptions: List[Any] = []  # List of autobahn subscriptions
+        self.registrations: List[Any] = []  # List of autobahn registrations
+        self.connection_drop_wait_time: int = 6000  # milliseconds
+        self.realm: Optional[str] = None
+        self.serial_number: Optional[str] = None
+        self._first_connection_future: Optional[asyncio.Future] = None
+        self._is_connected = False
+        self._session_wait_timeout = 6.0  # seconds
+        
+    @staticmethod
+    def getWebSocketURI():
+        reswarm_url = os.environ.get("RESWARM_URL")
+        if not reswarm_url:
+            return STUDIO_WS_URI
+        return socketURIMap.get(reswarm_url)
+        
+    async def configure(
+        self, 
+        swarm_key: int, 
+        app_key: int, 
+        stage: Stage,
+        cburl: Optional[str] = None,
+        serial_number: Optional[str] = None
+    ):
+        """
+        Configure the crossbar connection with realm and WAMPCRA authentication details.
+        
+        Args:
+            swarm_key: The swarm key identifier
+            app_key: The application key identifier  
+            stage: The deployment stage (development, production)
+            cburl: Optional crossbar URL (defaults to environment variable RESWARM_URL mapping)
+            serial_number: Optional device serial number (defaults to DEVICE_SERIAL_NUMBER env var)
+        """
+        self.realm = f"realm-{swarm_key}-{app_key}-{stage.value.lower()}"
+        self.serial_number = getSerialNumber(serial_number)
+        
+        # Get URL from environment if not provided
+        if cburl is None:
+            cburl = self.getWebSocketURI()
+            
+        self.connection_options = {
+            'url': cburl,
+            'realm': self.realm,
+            'authmethods': ['wampcra'],
+            'authid': self.serial_number,
+            'max_retries': -1,  # infinite retries
+            'max_retry_delay': 2,
+            'initial_retry_delay': 1,
+            'serializers': ['msgpack']
+        }
+        
+        # Create the component with WAMPCRA authentication
+        transports = [{
+            'type': 'websocket',
+            'url': cburl,
+            'serializers': ['msgpack']
+        }]
+        
+        # Custom session class for WAMPCRA authentication
+        class AppSession(ApplicationSession):
+            def onConnect(session_self):
+                print('onConnect called')
+                session_self.join(self.realm, ['wampcra'], self.serial_number)
+                
+            def onChallenge(session_self, challenge):
+                print(f'challenge requested for {challenge.method}')
+                if challenge.method == "wampcra":
+                    signature = auth.compute_wcs(
+                        self.serial_number, challenge.extra["challenge"]
+                    )
+                    return signature
+                raise Exception(f"Invalid authmethod {challenge.method}")
+        
+        self.component = Component(
+            transports=transports,
+            realm=self.realm,
+            session_factory=AppSession
+        )
+        
+        # Set up event handlers
+        self.component.on('join', self._on_open)
+        self.component.on('leave', self._on_close)
+        self.component.on('disconnect', self._on_disconnect)
+        
+        # Create future for first connection
+        self._first_connection_future = asyncio.Future()
+        
+    async def _on_open(self, session: ApplicationSession, details):
+        """Handle session open event"""
+        self.session = session
+        self._is_connected = True
+        await self._resubscribe_all()
+        print(f"Connection to IronFlock app realm '{session._realm}' established")
+        
+        if self._first_connection_future and not self._first_connection_future.done():
+            self._first_connection_future.set_result(None)
+            
+    async def _on_close(self, session: ApplicationSession, details):
+        """Handle session close event"""
+        self.session = None
+        self._is_connected = False
+        print(f"Connection to IronFlock app realm {self.realm} closed: {details.reason}")
+        
+        if self._first_connection_future and not self._first_connection_future.done():
+            self._first_connection_future.set_exception(
+                Exception(f"Connection closed: {details.reason}")
+            )
+            
+    async def _on_disconnect(self, session: ApplicationSession, was_clean: bool):
+        """Handle disconnect event"""
+        self.session = None
+        self._is_connected = False
+        print(f"Disconnected from IronFlock app realm {self.realm}, clean: {was_clean}")
+
+    async def _session_wait(self) -> None:
+        """Wait for session to be available"""
+        start_time = time.time()
+        while not self.session or not self._is_connected:
+            if time.time() - start_time > self._session_wait_timeout:
+                raise TimeoutError('Timeout waiting for session')
+            await asyncio.sleep(0.2)
+            
+    @property
+    def is_open(self) -> bool:
+        """Check if the connection is open"""
+        return self._is_connected and self.session is not None
+        
+    async def start(self) -> None:
+        """Start the connection"""
+        if not self.component:
+            raise ValueError("Must call configure() before start()")
+
+        print(f'Starting connection for IronFlock app realm {self.realm}')
+
+        # Start the component (non-blocking in autobahn asyncio)
+        self.component.start()
+        
+        # Wait for first connection to be established
+        if self._first_connection_future:
+            await self._first_connection_future
+            
+    async def stop(self) -> None:
+        """Stop the connection"""
+        if self.component:
+            await self.component.stop()
+        self._is_connected = False
+        self.session = None
+        
+    async def call(
+        self, 
+        topic: str, 
+        args: Optional[List[Any]] = None, 
+        kwargs: Optional[Dict[str, Any]] = None,
+        options: Optional[Dict[str, Any]] = None
+    ) -> Any:
+        """Call a remote procedure"""
+        await self._session_wait()
+        if not self.session:
+            raise RuntimeError("No active session")
+            
+        args = args or []
+        kwargs = kwargs or {}
+        
+        result = await self.session.call(topic, *args, **kwargs, options=options)
+        return result
+        
+    async def subscribe(
+        self, 
+        topic: str, 
+        handler: Callable,
+        options: Optional[Dict[str, Any]] = None
+    ) -> Optional[Any]:
+        """Subscribe to a topic"""
+        await self._session_wait()
+        if not self.session:
+            raise RuntimeError("No active session")
+            
+        subscription = await self.session.subscribe(handler, topic, options=options)
+        if subscription:
+            self.subscriptions.append(subscription)
+        return subscription
+        
+    async def publish(
+        self, 
+        topic: str, 
+        args: Optional[List[Any]] = None,
+        kwargs: Optional[Dict[str, Any]] = None,
+        options: Optional[Dict[str, Any]] = None
+    ) -> Optional[Any]:
+        """Publish to a topic"""
+        await self._session_wait()
+        if not self.session:
+            raise RuntimeError("No active session")
+            
+        args = args or []
+        kwargs = kwargs or {}
+        
+        result = await self.session.publish(topic, *args, options=options, **kwargs)
+        return result
+        
+    async def unsubscribe(self, subscription: Any) -> None:
+        """Unsubscribe from a subscription"""
+        await self._session_wait()
+        if not self.session:
+            raise RuntimeError("No active session")
+            
+        if subscription in self.subscriptions:
+            self.subscriptions.remove(subscription)
+            await self.session.unsubscribe(subscription)
+            
+    async def unsubscribe_func(
+        self, 
+        topic: str, 
+        handler: Optional[Callable] = None
+    ) -> None:
+        """Unsubscribe a specific function from a topic"""
+        await self._session_wait()
+        
+        if handler is None:
+            return await self.unsubscribe_topic(topic)
+            
+        # Find and remove subscriptions matching topic and handler
+        to_remove = []
+        for subscription in self.subscriptions:
+            if hasattr(subscription, 'topic') and subscription.topic == topic:
+                if hasattr(subscription, 'handler') and subscription.handler == handler:
+                    to_remove.append(subscription)
+                    
+        for subscription in to_remove:
+            try:
+                await self.unsubscribe(subscription)
+            except Exception as e:
+                print(f"Failed to unsubscribe from {topic}: {e}")
+                
+    async def unsubscribe_topic(self, topic: str) -> bool:
+        """Unsubscribe all handlers from a topic"""
+        matching_subs = [
+            sub for sub in self.subscriptions 
+            if hasattr(sub, 'topic') and sub.topic == topic
+        ]
+        
+        if not matching_subs:
+            return True
+            
+        # Unsubscribe all matching subscriptions
+        tasks = [self.unsubscribe(sub) for sub in matching_subs]
+        await asyncio.gather(*tasks, return_exceptions=True)
+        return True
+        
+    async def register(
+        self, 
+        topic: str, 
+        endpoint: Callable,
+        options: Optional[Dict[str, Any]] = None
+    ) -> Optional[Any]:
+        """Register a procedure"""
+        await self._session_wait()
+        if not self.session:
+            raise RuntimeError("No active session")
+            
+        registration = await self.session.register(endpoint, topic, options=options)
+        if registration:
+            self.registrations.append(registration)
+        return registration
+        
+    async def unregister(self, registration: Any) -> None:
+        """Unregister a procedure"""
+        await self._session_wait()
+        if not self.session:
+            raise RuntimeError("No active session")
+            
+        if registration in self.registrations:
+            self.registrations.remove(registration)
+            await self.session.unregister(registration)
+            
+    async def _resubscribe_all(self) -> None:
+        """Resubscribe to all topics after reconnection"""
+        if not self.subscriptions:
+            return
+            
+        print(f'Resubscribing to {len(self.subscriptions)} subscriptions')
+        
+        # Store current subscriptions and clear the list
+        old_subscriptions = self.subscriptions.copy()
+        self.subscriptions.clear()
+        
+        # Resubscribe to all topics
+        tasks = []
+        for old_sub in old_subscriptions:
+            if hasattr(old_sub, 'topic') and hasattr(old_sub, 'handler'):
+                task = self.subscribe(old_sub.topic, old_sub.handler)
+                tasks.append(task)
+                
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)

ironflock/__init__.py

@@ -1,10 +1,10 @@
-from ironflock.AutobahnConnection import (
-    create_application_component,
-    create_application_session,
-)
-
 from ironflock.ironflock import IronFlock
+from ironflock.CrossbarConnection import CrossbarConnection, Stage
 
-__all__ = ["IronFlock", "create_application_component", "create_application_session"]
+__all__ = [
+    "IronFlock", 
+    "CrossbarConnection",
+    "Stage"
+]
 
-__version__ = "1.0.8"
+__version__ = "1.2.0"

ironflock/ironflock.py

@@ -1,29 +1,26 @@
 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, RegisterOptions
-from autobahn.wamp.request import Publication
+from typing import Optional, Any
 
-from ironflock.AutobahnConnection import getSerialNumber, create_application_component
+from ironflock.CrossbarConnection import CrossbarConnection, Stage, getSerialNumber
+from autobahn.wamp.types import PublishOptions, RegisterOptions, SubscribeOptions, CallOptions
 
 
 class IronFlock:
-    """Conveniance class for easy-to-use message publishing in the IronFlock platform.
+    """Convenience class for easy-to-use message publishing in the IronFlock platform.
 
     Example:
 
         async def main():
             while True:
-                publication = await ironFlock.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__":
             ironflock = IronFlock(mainFunc=main)
-            ironFlock.run()
+            await ironflock.run()
     """
 
     def __init__(self, serial_number: str = None, mainFunc=None) -> None:
@@ -32,84 +29,114 @@ class IronFlock:
         Args:
             serial_number (str, optional): serial_number of device.
             Defaults to None, in which case the environment variable DEVICE_SERIAL_NUMBER is used.
+            mainFunc (callable, optional): Main function to run after connection is established.
         """
         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._connection = CrossbarConnection()
         self.mainFunc = mainFunc
         self._main_task = None
-
-        @self._component.on_join
-        async def onJoin(session, details):
-            print("component joined")
-            self._session = session
-            if self.mainFunc: 
-                self._main_task = asyncio.create_task(mainFunc())
-
-        @self._component.on_disconnect
-        @self._component.on_leave
-        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
+        self._is_configured = False
 
     @property
-    def component(self) -> Component:
-        """The Autobahn Component
+    def connection(self) -> CrossbarConnection:
+        """The CrossbarConnection instance
 
         Returns:
-            Component
+            CrossbarConnection
         """
-        return self._component
+        return self._connection
 
     @property
-    def session(self) -> Optional[ISession]:
-        """The Autobahn Session
+    def is_connected(self) -> bool:
+        """Check if the connection is established
 
         Returns:
-            Optional[ISession]
+            bool: True if connected, False otherwise
         """
-        return self._session
+        return self._connection.is_open
 
-    async def publish(self, topic: str, *args, **kwargs) -> Optional[Publication]:
+    async def _configure_connection(self):
+        """Configure the CrossbarConnection with environment variables"""
+        if self._is_configured:
+            return
+            
+        swarm_key = int(os.environ.get("SWARM_KEY", 0))
+        app_key = int(os.environ.get("APP_KEY", 0))
+        env_value = os.environ.get("ENV", "DEV").upper()
+        
+        # Map environment string to Stage enum
+        stage_map = {
+            "DEV": Stage.DEVELOPMENT,
+            "PROD": Stage.PRODUCTION
+        }
+        stage = stage_map.get(env_value, Stage.DEVELOPMENT)
+        
+        await self._connection.configure(
+            swarm_key=swarm_key,
+            app_key=app_key,
+            stage=stage,
+            serial_number=self._serial_number
+        )
+        self._is_configured = True
+
+    async def publish(self, topic: str, *args, **kwargs) -> Optional[Any]:
         """Publishes to the IronFlock Platform Message Router
 
         Args:
             topic (str): The URI of the topic to publish to, e.g. "com.myapp.mytopic1"
+            *args: Positional arguments to publish
+            **kwargs: Keyword arguments to publish
 
         Returns:
-            Optional[Publication]: Object representing a publication
+            Optional[Any]: Object representing a publication
             (feedback from publishing an event when doing an acknowledged publish)
         """
+        if not self.is_connected:
+            print("cannot publish, not connected")
+            return None
 
-        extra = {
+        # Add device metadata to kwargs
+        device_metadata = {
             "DEVICE_SERIAL_NUMBER": self._serial_number,
             "DEVICE_KEY": self._device_key,
             "DEVICE_NAME": self._device_name,
-            "options": PublishOptions(acknowledge=True),
         }
-
-        if self._session is not None:
-            pub = await self._session.publish(topic, *args, **kwargs, **extra)
+        
+        # Merge device metadata with user kwargs
+        combined_kwargs = {**device_metadata, **kwargs}
+        
+        # Use acknowledged publish with proper PublishOptions
+        options = PublishOptions(acknowledge=True)
+        
+        try:
+            pub = await self._connection.publish(
+                topic, 
+                args=list(args), 
+                kwargs=combined_kwargs,
+                options=options
+            )
             return pub
-        else:
-            print("cannot publish, not connected")
+        except Exception as e:
+            print(f"Publish failed: {e}")
+            return None
             
     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.
-            The location history will not be stored in the platform. 
-            If you need location history, then create a dedicated table for it.
+        
+        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.
+        
+        Args:
+            long (float): Longitude coordinate
+            lat (float): Latitude coordinate
         """
+        if not self.is_connected:
+            print("cannot set location, not connected")
+            return None
 
         payload = {
             "long": long,
@@ -122,69 +149,118 @@ class IronFlock:
             "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
+        try:
+            res = await self._connection.call(
+                'ironflock.location_service.update', 
+                args=[payload], 
+                kwargs=extra
+            )
+            return res
+        except Exception as e:
+            print(f"Set location failed: {e}")
+            return None
     
-    async def register_function(self, topic: str, func):
-        """Registers a function to be called when a message is received on the given topic.
-        
+    async def register(self, topic: str, endpoint, options: Optional[dict] = None) -> Optional[Any]:
+        """Registers a function with the IronFlock Platform Message Router
+
         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.
+            topic (str): The URI of the topic to register, e.g. "com.myapp.myprocedure1"
+            endpoint: The function to register
+            options (dict, optional): Registration options
+
+        Returns:
+            Optional[Any]: Object representing a registration
         """
-        swarm_key = os.environ.get("SWARM_KEY")
-        app_key = os.environ.get("APP_KEY")
-        env_value = os.environ.get("ENV")
-        
-        full_topic = f"{swarm_key}.{self._device_key}.{app_key}.{env_value}.{topic}"
-        
-        if self._session is not None:
-            await self._session.register(func, full_topic, options=RegisterOptions(force_reregister=True))
-        else:
-            print("cannot register function, not connected")
+        if not self.is_connected:
+            print("cannot register, not connected")
+            return None
+
+        # Convert options dict to RegisterOptions if provided
+        register_options = RegisterOptions(**options) if options else None
+
+        try:
+            reg = await self._connection.register(topic, endpoint, options=register_options)
+            return reg
+        except Exception as e:
+            print(f"Register failed: {e}")
+            return None
 
-    async def call(self, device_key, topic, args, kwargs):
-        """Calls a remote procedure on the IronFlock platform.
+    async def subscribe(self, topic: str, handler, options: Optional[dict] = None) -> Optional[Any]:
+        """Subscribes to a topic on the IronFlock Platform Message Router
 
         Args:
-            device_key (str): The key of the device to call the procedure on.
-            topic (str): The URI of the topic to call, e.g. "com.myprocedure".
-            args (list): The arguments to pass to the procedure.
-            kwargs (dict): The keyword arguments to pass to the procedure.
+            topic (str): The URI of the topic to subscribe to, e.g. "com.myapp.mytopic1"
+            handler: The function to call when a message is received
+            options (dict, optional): Subscription options
 
         Returns:
-            The result of the remote procedure call.
+            Optional[Any]: Object representing a subscription
         """
-        
-        swarm_key = os.environ.get("SWARM_KEY")
-        app_key = os.environ.get("APP_KEY")
-        env_value = os.environ.get("ENV")
-        
-        full_topic = f"{swarm_key}.{device_key}.{app_key}.{env_value}.{topic}"
-        
-        if self._session is not None:
-            return await self._session.call(full_topic, *args, **kwargs)
-        else:
+        if not self.is_connected:
+            print("cannot subscribe, not connected")
+            return None
+
+        # Convert options dict to SubscribeOptions if provided
+        subscribe_options = SubscribeOptions(**options) if options else None
+
+        try:
+            sub = await self._connection.subscribe(topic, handler, options=subscribe_options)
+            return sub
+        except Exception as e:
+            print(f"Subscribe failed: {e}")
+            return None
+
+    async def call(self, device_key: str, topic: str, args: list = None, kwargs: dict = None, options: Optional[dict] = None):
+        """Calls a remote procedure registered by another IronFlock device
+
+        Args:
+            device_key (str): The device key of the target device
+            topic (str): The URI of the topic to call, e.g. "com.myapp.myprocedure1"
+            args (list, optional): Positional arguments for the call. Defaults to None.
+            kwargs (dict, optional): Keyword arguments for the call. Defaults to None.
+            options (dict, optional): Call options. Defaults to None.
+
+        Returns:
+            Any: The result of the remote procedure call
+        """
+        if not self.is_connected:
             print("cannot call, not connected")
             return None
 
+        args = args or []
+        kwargs = kwargs or {}
+
+        # Convert options dict to CallOptions if provided
+        call_options = CallOptions(**options) if options else None
+
+        call_topic = f"{device_key}.{topic}"
+
+        try:
+            result = await self._connection.call(call_topic, args=args, kwargs=kwargs, options=call_options)
+            return result
+        except Exception as e:
+            print(f"Call failed: {e}")
+            return None
+
     async def publish_to_table(
         self, tablename: str, *args, **kwargs
-    ) -> Optional[Publication]:
-        """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.
+    ) -> Optional[Any]:
+        """Publishes Data to a Table in the IronFlock Platform. This is a convenience 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"
+            *args: Positional arguments to publish
+            **kwargs: Keyword arguments to publish
 
         Returns:
-            Optional[Publication]: Object representing a publication
+            Optional[Any]: Object representing a publication
             (feedback from publishing an event when doing an acknowledged publish)
         """
 
@@ -193,7 +269,6 @@ class IronFlock:
 
         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!")
@@ -206,9 +281,47 @@ class IronFlock:
         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()
+    async def start(self):
+        """Start the connection and run the main function if provided"""
+        await self._configure_connection()
+        await self._connection.start()
+        
+        if self.mainFunc:
+            self._main_task = asyncio.create_task(self.mainFunc())
+        
+    async def stop(self):
+        """Stop the connection and cancel the main task if running"""
+        if self._main_task and not self._main_task.done():
+            self._main_task.cancel()
+            try:
+                await self._main_task
+            except asyncio.CancelledError:
+                pass
+            self._main_task = None
+            
+        if self._connection:
+            await self._connection.stop()
+
+    async def run(self):
+        """Start the connection and keep it running"""
+        await self.start()
+        
+        try:
+            # Keep running until manually stopped
+            if self._main_task:
+                await self._main_task
+            else:
+                # If no main function, just wait indefinitely
+                while self.is_connected:
+                    await asyncio.sleep(1)
+        except KeyboardInterrupt:
+            print("Shutting down...")
+        except Exception as e:
+            print(f"Exception in run(): {e}")
+            raise
+        finally:
+            await self.stop()
+
+    def run_sync(self):
+        """Synchronous wrapper to run the IronFlock instance (for backward compatibility)"""
+        asyncio.run(self.run())

{ironflock-1.1.0.dist-info → ironflock-1.2.1.dist-info}/METADATA

@@ -1,24 +1,27 @@
 Metadata-Version: 2.4
 Name: ironflock
-Version: 1.1.0
-Summary: SDK to integrate your IronFlock Industry 4 Apps with the IronFlock Data Infrastructure
-Author-email: Record Evolution GmbH <marko.petzold@record-evolution.de>
+Version: 1.2.1
+Summary: IronFlock Python SDK for connecting to the IronFlock Platform
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/RecordEvolution/ironflock-py
-Project-URL: Repository, https://github.com/RecordEvolution/ironflock-py
+License-File: LICENSE
+Author: Marko Petzold, IronFlock GmbH
+Author-email: info@ironflock.com
+Requires-Python: >=3.9
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
+Provides-Extra: dev
+Provides-Extra: docs
+Requires-Dist: autobahn[asyncio,serialization] (==24.4.2)
+Requires-Dist: mypy ; extra == "dev"
+Requires-Dist: pydantic ; extra == "dev"
+Requires-Dist: pytest ; extra == "dev"
+Requires-Dist: ruff ; extra == "dev"
+Requires-Dist: sphinx (>=7) ; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints (>=2.0) ; extra == "docs"
+Requires-Dist: sphinx-book-theme (>=1.1.4) ; extra == "docs"
+Project-URL: Homepage, https://github.com/RecordEvolution/ironflock-py
+Project-URL: Repository, https://github.com/RecordEvolution/ironflock-py
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: autobahn[asyncio,serialization]==24.4.2
-Dynamic: license-file
 
 # ironflock
 

ironflock-1.2.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+ironflock/CrossbarConnection.py,sha256=kWoWQ8TqZORq5XhuL3-c22yIFBzGMpRbCZpztKPMNyQ,12802
+ironflock/__init__.py,sha256=5DreQfXO9MKAaEDxHm_L2fzCdbt9gRg3K8bV--ESoMo,203
+ironflock/ironflock.py,sha256=3Qd4VvrxTn5nekRZhwIzj_XFbr3Mayct0XzCkYSwK-8,11674
+ironflock-1.2.1.dist-info/METADATA,sha256=4ZU45mFIsw8wQ5mMiMRySmtjFwSG2jwmuXfhzr--_BM,3425
+ironflock-1.2.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+ironflock-1.2.1.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
+ironflock-1.2.1.dist-info/RECORD,,

{ironflock-1.1.0.dist-info → ironflock-1.2.1.dist-info}/WHEEL

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

examples/app_session.py

@@ -1,32 +0,0 @@
-###
-# Minimal example of creating an Autobahn asyncio ApplicationSession
-# for connecting to the IronFlock Platform.
-# Compared to the IronFlock() class, the ApplicationSession approach allows
-# more control reacting to the lifecycle of the Session:
-# you can register callback functions like on_join or on_leave.
-# For more details checkout:
-# https://autobahn.readthedocs.io/en/latest/wamp/programming.html#application-components
-###
-
-from asyncio import sleep
-from autobahn.wamp.interfaces import ISession
-from ironflock import create_application_session
-
-# returns an Autobahn asyncio ApplicationSession and ApplicationRunner, for more information checkout:
-# https://autobahn.readthedocs.io/en/latest/reference/autobahn.asyncio.html
-AppSession, runner = create_application_session()
-
-
-class Application(AppSession):
-    async def onJoin(session: ISession, details):
-        print("joined router")
-        print(session, details)
-
-        # publish an event every second
-        while True:
-            session.publish("test.publish.com", 1, "two", 3, foo="bar")
-            await sleep(1)
-
-
-if __name__ == "__main__":
-    runner.run(Application)

examples/component.py

@@ -1,40 +0,0 @@
-###
-# Minimal example of creating an Autobahn asyncio Component
-# for connecting to the IronFlock Platform.
-# Compared to the IronFlock() class, the Component approach allows
-# more control, e.g. reacting to the lifecycle of the component:
-# you can register callback functions like on_join or on_leave.
-# For more details checkout:
-# https://autobahn.readthedocs.io/en/latest/wamp/programming.html#application-components
-###
-
-from asyncio import sleep
-from autobahn.asyncio.component import run
-from autobahn.wamp.interfaces import ISession
-from ironflock import create_application_component
-
-# returns an Autobahn asyncio Component, for more information checkout:
-# https://autobahn.readthedocs.io/en/latest/reference/autobahn.asyncio.html
-comp = create_application_component()
-
-
-@comp.on_join
-async def onJoin(session: ISession, details):
-    print("joined router")
-    print(session, details)
-
-    def handler(*args, **kwargs):
-        print("got event")
-        print(args, kwargs)
-
-    # subscribe to a topic
-    session.subscribe(handler, "test.publish.com")
-
-    # publish an event every second
-    while True:
-        session.publish("test.publish.com", 1, "two", 3, foo="bar")
-        await sleep(1)
-
-
-if __name__ == "__main__":
-    run([comp])

examples/simple_publish.py

@@ -1,25 +0,0 @@
-###
-# Minimal example of publishing events to the IronFlock Platform.
-###
-
-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 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", 1, "two", 3, foo="bar")
-        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()

examples/table_publish.py

@@ -1,29 +0,0 @@
-###
-# Minimal example of publishing events to the IronFlock Platform.
-###
-
-import asyncio
-from datetime import datetime
-from ironflock import IronFlock
-
-# create a ironflock instance, which auto connects to the IronFlock Platform
-# the ironflock instance handles authentication and reconnects when 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_to_table(
-            "sensordata",
-            dict(temperature=25, tsp=datetime.now().astimezone().isoformat()),
-        )
-        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()

ironflock/AutobahnConnection.py

@@ -1,126 +0,0 @@
-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!")
-
-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"
-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:8086": LOCALHOST_WS_URI,
-    "http://host.docker.internal:8086": 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 IronFlock 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 IronFlock 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-1.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-examples/app_session.py,sha256=ugpaZkqbhcn_DzIMrCLSoPjcPtacyKEDVWj0V2fHZJc,1151
-examples/component.py,sha256=1wvYL1QSRh6t9csh_WPZiMB6GtfmU7PGwSYZtNfQyTg,1255
-examples/simple_publish.py,sha256=3wImf1nikJEHynIvMSx4ofiSFhhbdsBJw3awLA-wYcE,720
-examples/table_publish.py,sha256=IXsWRoLI9u1CqH_9mB-k4TLYEVOjGtcXzWQ3mzcxg1Q,831
-ironflock/AutobahnConnection.py,sha256=Xh1Y7s269XdLTfDYe6moTiJda7cPzCkknICSqxN3fn4,3744
-ironflock/__init__.py,sha256=Ia3Bb7BjyuGl1YBp3fHz0tHS-CsDtH-JSrjbtl-u7S4,264
-ironflock/ironflock.py,sha256=3OftdBL1Fb4fMKNz3ttnycMAN3GmruIkFkjmKaOzahQ,7867
-ironflock-1.1.0.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
-test/main.py,sha256=Gp4N9nuUWrCDti4-9W5AoGFDX2cWujKg3Bbq1kJcEP8,328
-ironflock-1.1.0.dist-info/METADATA,sha256=hD_x-g1q0ZV4BXPLIsYYTd5byJ2j1jGCKKxGXLPQBXc,3403
-ironflock-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ironflock-1.1.0.dist-info/top_level.txt,sha256=ik-lPYQ3yaZZm6kJURMiJmM2MJh9ExxRSOy-HruvpwY,24
-ironflock-1.1.0.dist-info/RECORD,,

ironflock-1.1.0.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-examples
-ironflock
-test

test/main.py

@@ -1,10 +0,0 @@
-from asyncio.events import get_event_loop
-from ironflock import IronFlock
-
-async def main():
-    rw = IronFlock(serial_number="7652ee0b-c2cb-466a-b8ee-fec4167bf7ce")
-    result = await rw.publish('re.meetup.data', {"temperature": 20})
-    print(result)
-
-if __name__ == "__main__":
-    get_event_loop().run_until_complete(main())