ironflock 1.0.9__py3-none-any.whl → 1.2.0__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 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 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 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 realm {self.realm}')
+        
+        # Start the component
+        await self.component.start()
+        
+        # Wait for first connection
+        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,25 @@
 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
 
 
 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 +28,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
+        options = {"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,9 +148,16 @@ 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.
@@ -133,18 +166,26 @@ class IronFlock:
             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.
         """
+        if not self.is_connected:
+            print("cannot register function, 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}"
         
-        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")
+        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
+        except Exception as e:
+            print(f"Register function failed: {e}")
+            return None
 
-    async def call(self, device_key, topic, args, kwargs):
+    async def call(self, device_key: str, topic: str, args: list = None, kwargs: dict = None):
         """Calls a remote procedure on the IronFlock platform.
 
         Args:
@@ -156,35 +197,46 @@ class IronFlock:
         Returns:
             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}"
         
-        if self._session is not None:
-            return await self._session.call(full_topic, *args, **kwargs)
-        else:
-            print("cannot call, not connected")
+        try:
+            result = await self._connection.call(
+                full_topic, 
+                args=args or [], 
+                kwargs=kwargs or {}
+            )
+            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 +245,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 +257,43 @@ 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
+            
+        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...")
+        finally:
+            await self.stop()
+
+    def run_sync(self):
+        """Synchronous wrapper to run the IronFlock instance (for backward compatibility)"""
+        asyncio.run(self.run())

{ironflock-1.0.9.dist-info → ironflock-1.2.0.dist-info}/METADATA

@@ -1,25 +1,27 @@
 Metadata-Version: 2.4
 Name: ironflock
-Version: 1.0.9
-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
+Version: 1.2.0
+Summary: IronFlock Python SDK for connecting to the IronFlock Platform
+License-Expression: MIT
 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
+Author: Marko Petzold, IronFlock GmbH
+Author-email: info@ironflock.com
+Requires-Python: >=3.9
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+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
 
 # ironflock
 
@@ -32,6 +34,19 @@ 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.
+
+## Requirements
+
+- Python 3.8 or higher
+- Compatible with Python 3.8, 3.9, 3.10, 3.11, and 3.12
+
+## Installation
+
+Install from PyPI:
+
+```shell
+pip install ironflock
+```
 ## Usage
 
 ```python
@@ -75,10 +90,10 @@ the [examples](https://github.com/RecordEvolution/ironflock-py/tree/main/example
 
 ## Development
 
-Install the necessary components if you don't have them already:
+Install the necessary build tools if you don't have them already:
 
 ```shell
-pip install --upgrade setuptools wheel twine
+pip install --upgrade build twine
 ```
 
 Build and publish a new pypi package:
@@ -87,4 +102,17 @@ Build and publish a new pypi package:
 just publish
 ```
 
+Alternatively, you can build manually:
+
+```shell
+# Clean previous builds
+rm -rf build dist *.egg-info
+
+# Build the package
+python -m build
+
+# Upload to PyPI
+twine upload dist/*
+```
+
 Check the package at https://pypi.org/project/ironflock/.

ironflock-1.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+ironflock/CrossbarConnection.py,sha256=Q7SNHTNbi7AJC4SbFf7_TLqS10dIGGzJnwY0iVIU2Ek,12727
+ironflock/__init__.py,sha256=5DreQfXO9MKAaEDxHm_L2fzCdbt9gRg3K8bV--ESoMo,203
+ironflock/ironflock.py,sha256=Efs6cAl7dP6CzN1XRFQRg6xw7ULIX_4EvXpXDXUJUK0,10531
+ironflock-1.2.0.dist-info/METADATA,sha256=6N0-bI8AzKlbBTO4kMj_fQSdOHBVCXLczzaF_r6uoJI,3425
+ironflock-1.2.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+ironflock-1.2.0.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
+ironflock-1.2.0.dist-info/RECORD,,

{ironflock-1.0.9.dist-info → ironflock-1.2.0.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
-

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.0.9.dist-info/RECORD

@@ -1,8 +0,0 @@
-ironflock/AutobahnConnection.py,sha256=Xh1Y7s269XdLTfDYe6moTiJda7cPzCkknICSqxN3fn4,3744
-ironflock/__init__.py,sha256=Ia3Bb7BjyuGl1YBp3fHz0tHS-CsDtH-JSrjbtl-u7S4,264
-ironflock/ironflock.py,sha256=3OftdBL1Fb4fMKNz3ttnycMAN3GmruIkFkjmKaOzahQ,7867
-ironflock-1.0.9.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
-ironflock-1.0.9.dist-info/METADATA,sha256=eEG8bSTbMgUJlf9hdMsGxkwlDDFr--j-icJAnBx-8PU,2764
-ironflock-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ironflock-1.0.9.dist-info/top_level.txt,sha256=hmMdMPJuvnOTlFKYl1XQOn81vg1DE2LT7xrEXgyxcRA,10
-ironflock-1.0.9.dist-info/RECORD,,

ironflock-1.0.9.dist-info/top_level.txt

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