ironflock 1.2.0__tar.gz → 1.3.0__tar.gz

{ironflock-1.2.0 → ironflock-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ironflock
-Version: 1.2.0
+Version: 1.3.0
 Summary: IronFlock Python SDK for connecting to the IronFlock Platform
 License-Expression: MIT
 License-File: LICENSE

{ironflock-1.2.0 → ironflock-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ironflock"
-version = "1.2.0"
+version = "1.3.0"
 description = "IronFlock Python SDK for connecting to the IronFlock Platform"
 authors = [
     {name = "Marko Petzold, IronFlock GmbH", email = "info@ironflock.com"}

{ironflock-1.2.0 → ironflock-1.3.0}/src/ironflock/CrossbarConnection.py

@@ -138,7 +138,7 @@ class CrossbarConnection:
         self.session = session
         self._is_connected = True
         await self._resubscribe_all()
-        print(f"Connection to realm '{session._realm}' established")
+        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)
@@ -147,7 +147,7 @@ class CrossbarConnection:
         """Handle session close event"""
         self.session = None
         self._is_connected = False
-        print(f"Connection to realm {self.realm} closed: {details.reason}")
+        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(
@@ -158,8 +158,8 @@ class CrossbarConnection:
         """Handle disconnect event"""
         self.session = None
         self._is_connected = False
-        print(f"Disconnected from realm {self.realm}, clean: {was_clean}")
-        
+        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()
@@ -177,13 +177,13 @@ class CrossbarConnection:
         """Start the connection"""
         if not self.component:
             raise ValueError("Must call configure() before start()")
-            
-        print(f'Starting connection for realm {self.realm}')
-        
-        # Start the component
-        await self.component.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
+        # Wait for first connection to be established
         if self._first_connection_future:
             await self._first_connection_future
             

{ironflock-1.2.0 → ironflock-1.3.0}/src/ironflock/__init__.py

@@ -7,4 +7,4 @@ __all__ = [
     "Stage"
 ]
 
-__version__ = "1.2.0"
+__version__ = "1.3.0"

{ironflock-1.2.0 → ironflock-1.3.0}/src/ironflock/ironflock.py

@@ -3,6 +3,7 @@ import asyncio
 from typing import Optional, Any
 
 from ironflock.CrossbarConnection import CrossbarConnection, Stage, getSerialNumber
+from autobahn.wamp.types import PublishOptions, RegisterOptions, SubscribeOptions, CallOptions
 
 
 class IronFlock:
@@ -106,8 +107,8 @@ class IronFlock:
         # Merge device metadata with user kwargs
         combined_kwargs = {**device_metadata, **kwargs}
         
-        # Use acknowledged publish
-        options = {"acknowledge": True}
+        # Use acknowledged publish with proper PublishOptions
+        options = PublishOptions(acknowledge=True)
         
         try:
             pub = await self._connection.publish(
@@ -159,60 +160,87 @@ class IronFlock:
             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_function(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
         """
         if not self.is_connected:
-            print("cannot register function, not connected")
+            print("cannot register, not connected")
             return None
-            
-        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}"
-        
+
+        # Convert options dict to RegisterOptions if provided
+        register_options = RegisterOptions(**options) if options else None
+
         try:
-            # Note: CrossbarConnection doesn't support force_reregister option directly
-            # but it handles resubscription automatically on reconnect
-            registration = await self._connection.register(full_topic, func)
-            return registration
+            reg = await self._connection.register(topic, endpoint, options=register_options)
+            return reg
         except Exception as e:
-            print(f"Register function failed: {e}")
+            print(f"Register failed: {e}")
             return None
 
-    async def call(self, device_key: str, topic: str, args: list = None, kwargs: dict = None):
-        """Calls a remote procedure on the IronFlock platform.
+    async def register(self, topic: str, endpoint, options: Optional[dict] = None) -> Optional[Any]:
+        """Alias for register_function() for backward compatibility"""
+        return await self.register_function(topic, endpoint, options)
+
+    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
+        """
+        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
-            
-        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}"
-        
+
+        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(
-                full_topic, 
-                args=args or [], 
-                kwargs=kwargs or {}
-            )
+            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}")
@@ -275,9 +303,14 @@ class IronFlock:
                 pass
             self._main_task = None
             
-        await self._connection.stop()
+        if self._connection:
+            await self._connection.stop()
 
-    async def run(self):
+    def run(self):
+        """Synchronous wrapper to run the IronFlock instance (original API)"""
+        asyncio.run(self.run_async())
+
+    async def run_async(self):
         """Start the connection and keep it running"""
         await self.start()
         
@@ -291,9 +324,12 @@ class IronFlock:
                     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())
+        """Alias for run() method for clarity"""
+        return self.run()