ironflock 1.3.8__py3-none-any.whl → 1.3.9__py3-none-any.whl

ironflock/CrossbarConnection.py

@@ -1,5 +1,4 @@
 import asyncio
-import time
 import os
 from typing import Optional, List, Dict, Any, Callable
 from autobahn.asyncio.wamp import ApplicationSession
@@ -31,7 +30,7 @@ def getSerialNumber(serial_number: str = None) -> str:
 STUDIO_DEV_WS_URI = "wss://cbw.ironflock.dev/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"
+LOCALHOST_WS_URI = "ws://localhost:18080/ws-ua-usr"
 
 socketURIMap = {
     "https://studio.ironflock.dev": STUDIO_DEV_WS_URI,
@@ -56,9 +55,13 @@ class CrossbarConnection:
         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._connection_event: Optional[asyncio.Event] = None
         self._is_connected = False
         self._session_wait_timeout = 6.0  # seconds
+        self._first_connection_timeout = 30.0  # seconds - timeout for initial connection
+        self._max_connection_retries = 5  # maximum retries for first connection
+        self._connection_error: Optional[Exception] = None
+        self._component_task: Optional[asyncio.Task] = None
         
     @staticmethod
     def getWebSocketURI():
@@ -136,18 +139,21 @@ class CrossbarConnection:
         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()
+        # Create event for connection signaling (can be reset unlike Future)
+        self._connection_event = asyncio.Event()
+        self._connection_error = None
         
     async def _on_open(self, session: ApplicationSession, details):
         """Handle session open event"""
         self.session = session
         self._is_connected = True
+        self._connection_error = None
         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)
+        # Signal that connection is established
+        if self._connection_event:
+            self._connection_event.set()
             
     async def _on_close(self, session: ApplicationSession, details):
         """Handle session close event"""
@@ -155,25 +161,48 @@ class CrossbarConnection:
         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():
-            print(f"⚠️  Initial connection attempt failed: {details.reason}")
-            print("🔄 Will keep trying to reconnect...")
-            # Resolve the future so start() doesn't crash, Autobahn will keep retrying
-            self._first_connection_future.set_result(None)
+        # Store error for connection waiters
+        self._connection_error = Exception(f"Connection closed: {details.reason}")
+        
+        # Reset event so next connection attempt can wait
+        if self._connection_event:
+            self._connection_event.clear()
             
     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}")
+        
+        # Reset event so next connection attempt can wait
+        if self._connection_event:
+            self._connection_event.clear()
 
     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:
+        if self.session and self._is_connected:
+            return
+            
+        # If we have a connection event, wait on it with timeout
+        if self._connection_event:
+            try:
+                await asyncio.wait_for(
+                    self._connection_event.wait(),
+                    timeout=self._session_wait_timeout
+                )
+            except asyncio.TimeoutError:
                 raise TimeoutError('Timeout waiting for session')
-            await asyncio.sleep(0.2)
+        else:
+            # No connection event means configure() wasn't called or connection not started
+            # Wait with timeout using sleep-based approach
+            await asyncio.sleep(self._session_wait_timeout)
+            raise TimeoutError('Timeout waiting for session')
+        
+        # Double-check we have a valid session
+        if not self.session or not self._is_connected:
+            if self._connection_error:
+                raise self._connection_error
+            raise RuntimeError('Session not available')
             
     @property
     def is_open(self) -> bool:
@@ -181,18 +210,112 @@ class CrossbarConnection:
         return self._is_connected and self.session is not None
         
     async def start(self) -> None:
-        """Start the connection"""
+        """Start the connection with timeout and retry logic"""
         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()
+        last_error: Optional[Exception] = None
         
-        # Wait for first connection to be established
-        if self._first_connection_future:
-            await self._first_connection_future
+        for attempt in range(1, self._max_connection_retries + 1):
+            try:
+                # Reset connection state for this attempt
+                self._connection_error = None
+                if self._connection_event:
+                    self._connection_event.clear()
+                
+                # Stop any existing component task
+                if self._component_task and not self._component_task.done():
+                    self._component_task.cancel()
+                    try:
+                        await self._component_task
+                    except asyncio.CancelledError:
+                        pass
+                
+                # Start the component in a background task
+                self._component_task = asyncio.create_task(self._run_component())
+                
+                # Wait for connection with timeout
+                if self._connection_event:
+                    try:
+                        await asyncio.wait_for(
+                            self._connection_event.wait(),
+                            timeout=self._first_connection_timeout
+                        )
+                        
+                        # Check if we actually connected or got an error
+                        if self._is_connected and self.session:
+                            print(f"Successfully connected on attempt {attempt}")
+                            return
+                        elif self._connection_error:
+                            raise self._connection_error
+                            
+                    except asyncio.TimeoutError:
+                        print(f"Connection attempt {attempt}/{self._max_connection_retries} timed out after {self._first_connection_timeout}s")
+                        last_error = TimeoutError(f"Connection timed out after {self._first_connection_timeout}s")
+                        
+                        # Stop the component before retrying
+                        await self._stop_component()
+                        
+                        if attempt < self._max_connection_retries:
+                            retry_delay = min(2 ** attempt, 30)  # Exponential backoff, max 30s
+                            print(f"Retrying in {retry_delay}s...")
+                            await asyncio.sleep(retry_delay)
+                        continue
+                        
+            except Exception as e:
+                last_error = e
+                print(f"Connection attempt {attempt}/{self._max_connection_retries} failed: {e}")
+                
+                # Stop the component before retrying
+                await self._stop_component()
+                
+                if attempt < self._max_connection_retries:
+                    retry_delay = min(2 ** attempt, 30)  # Exponential backoff, max 30s
+                    print(f"Retrying in {retry_delay}s...")
+                    await asyncio.sleep(retry_delay)
+                continue
+        
+        # All retries exhausted
+        raise ConnectionError(
+            f"Failed to connect after {self._max_connection_retries} attempts. Last error: {last_error}"
+        )
+    
+    async def _run_component(self) -> None:
+        """Run the component in the background"""
+        try:
+            await self.component.start()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            print(f"Component error: {e}")
+            self._connection_error = e
+            if self._connection_event:
+                self._connection_event.set()  # Signal to unblock waiters
+    
+    async def _stop_component(self) -> None:
+        """Stop the component and cleanup"""
+        try:
+            if self._component_task and not self._component_task.done():
+                self._component_task.cancel()
+                try:
+                    await asyncio.wait_for(self._component_task, timeout=5.0)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
+            
+            if self.component:
+                try:
+                    await asyncio.wait_for(self.component.stop(), timeout=5.0)
+                except asyncio.TimeoutError:
+                    print("Component stop timed out")
+                except Exception as e:
+                    print(f"Error stopping component: {e}")
+        except Exception as e:
+            print(f"Error during component cleanup: {e}")
+        finally:
+            self._is_connected = False
+            self.session = None
             
     async def stop(self) -> None:
         """Stop the connection"""
@@ -294,7 +417,7 @@ class CrossbarConnection:
         self, 
         topic: str, 
         handler: Optional[Callable] = None
-    ) -> None:
+    ) -> bool:
         """Unsubscribe a specific function from a topic"""
         await self._session_wait()
         
@@ -313,7 +436,9 @@ class CrossbarConnection:
                 await self.unsubscribe(subscription)
             except Exception as e:
                 print(f"Failed to unsubscribe from {topic}: {e}")
-                
+                return False
+        return True
+
     async def unsubscribe_topic(self, topic: str) -> bool:
         """Unsubscribe all handlers from a topic"""
         matching_subs = [

ironflock/__init__.py

@@ -1,3 +1,5 @@
+from importlib.metadata import version, PackageNotFoundError
+
 from ironflock.ironflock import IronFlock
 from ironflock.CrossbarConnection import CrossbarConnection, Stage
 
@@ -7,4 +9,7 @@ __all__ = [
     "Stage"
 ]
 
-__version__ = "1.3.8"
+try:
+    __version__ = version("ironflock")
+except PackageNotFoundError:
+    __version__ = "0.0.0"  # fallback for development

{ironflock-1.3.8.dist-info → ironflock-1.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ironflock
-Version: 1.3.8
+Version: 1.3.9
 Summary: IronFlock Python SDK for connecting to the IronFlock Platform
 License-Expression: MIT
 License-File: LICENSE
@@ -11,11 +11,12 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Provides-Extra: dev
 Provides-Extra: docs
-Requires-Dist: autobahn[asyncio,serialization] (==25.10.2)
+Requires-Dist: autobahn[asyncio,serialization] (==25.12.2)
 Requires-Dist: mypy ; extra == "dev"
 Requires-Dist: pydantic (>=2.0.0)
 Requires-Dist: pydantic ; extra == "dev"
 Requires-Dist: pytest ; extra == "dev"
+Requires-Dist: pytest-asyncio ; extra == "dev"
 Requires-Dist: ruff ; extra == "dev"
 Requires-Dist: sphinx (>=8.2.3) ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints (>=2.0) ; extra == "docs"
@@ -90,42 +91,70 @@ the [examples](https://github.com/RecordEvolution/ironflock-py/tree/main/example
 
 ## Development
 
-Install the necessary build tools if you don't have them already:
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management and building.
+
+Install uv if you don't have it:
+
+```shell
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Install dependencies (including dev dependencies):
+
+```shell
+uv sync --extra dev
+```
+
+Run tests:
 
 ```shell
-pip install --upgrade build twine
+just test-unit    # Run unit tests only
+just test         # Run all tests
+just test-docker  # Run integration tests with Docker
 ```
 
-Make sure your pypi API tokens are stored in your `~/.pypirc`.
 Build and publish a new pypi package:
 
 ```shell
 just publish
 ```
 
-Alternatively, you can build manually:
+Or manually:
 
 ```shell
 # Clean previous builds
-rm -rf build dist *.egg-info
+rm -rf dist
 
 # Build the package
-python -m build
+uv build
 
 # Upload to PyPI
-twine upload dist/*
+uv publish
 ```
 
 Check the package at https://pypi.org/project/ironflock/.
 
 ## Test Deployment
 
-To test the package before deploying to pypi you can use test.pypi.
+To test the package before deploying to PyPI you can use test.pypi.
 
 ```shell
 just clean build publish-test
 ```
 
+Or manually:
+
+```shell
+uv build
+uv publish --publish-url https://test.pypi.org/legacy/
+```
+
+Once the package is published you can install it from TestPyPI:
+
+```shell
+pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ ironflock
+```
+
 Once the package is published you can use it in other code by putting
 these lines at the top of the requirements.txt
 
@@ -134,4 +163,3 @@ these lines at the top of the requirements.txt
 --extra-index-url https://pypi.org/simple/
 ```
 
-

ironflock-1.3.9.dist-info/RECORD

@@ -0,0 +1,8 @@
+ironflock/CrossbarConnection.py,sha256=hDihh2RQYTbQLF4WD0WvSxpEK9RRcq7Fu-AhlavdM3s,19816
+ironflock/__init__.py,sha256=yzf44H-czcGrOft1mVVnsGIPpn6DgQ0feTD6syHOf2k,370
+ironflock/ironflock.py,sha256=sLP0Mfp3bgtyE0Qv7LTUDOY8YlRDM0PxJG8eZplluoU,19536
+ironflock/types.py,sha256=yync91abyrI1fqbmczW5My7Skx7-8soENGHK2JfaEz0,11962
+ironflock-1.3.9.dist-info/METADATA,sha256=1gbys7ut1kLmiJR8XvdB9XwtlUyaIJcSWvcoial6Xkc,4335
+ironflock-1.3.9.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+ironflock-1.3.9.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
+ironflock-1.3.9.dist-info/RECORD,,

{ironflock-1.3.8.dist-info → ironflock-1.3.9.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any

ironflock-1.3.8.dist-info/RECORD

@@ -1,8 +0,0 @@
-ironflock/CrossbarConnection.py,sha256=S-vjfjIdNpvfNnsPhCV18JHuFN36tpCzqbwxbwHpmow,14301
-ironflock/__init__.py,sha256=FzPwMngsi8VXjeFYfK6D-3a17SbYFIPErWG1cA5qT0c,203
-ironflock/ironflock.py,sha256=sLP0Mfp3bgtyE0Qv7LTUDOY8YlRDM0PxJG8eZplluoU,19536
-ironflock/types.py,sha256=yync91abyrI1fqbmczW5My7Skx7-8soENGHK2JfaEz0,11962
-ironflock-1.3.8.dist-info/METADATA,sha256=257ZiWssGu7T5iqAQtJXZRjp4pXX03peTHaqBLBp0VA,3820
-ironflock-1.3.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-ironflock-1.3.8.dist-info/licenses/LICENSE,sha256=GpUKjPB381nmkbBIdX74vxXhsNZaNpngTOciss39Pjk,1073
-ironflock-1.3.8.dist-info/RECORD,,