ctrader-api-client 0.5.0__tar.gz → 0.5.1__tar.gz

{ctrader_api_client-0.5.0 → ctrader_api_client-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrader-api-client
-Version: 0.5.0
+Version: 0.5.1
 Summary: API Client to interact with the cTrader Open API spec
 Author-email: Elio <elioachukri@pm.me>
 License-File: LICENSE

{ctrader_api_client-0.5.0 → ctrader_api_client-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrader-api-client"
-version = "0.5.0"
+version = "0.5.1"
 description = "API Client to interact with the cTrader Open API spec"
 readme = "README.md"
 authors = [

{ctrader_api_client-0.5.0 → ctrader_api_client-0.5.1}/src/ctrader_api_client/connection/heartbeat.py

@@ -84,6 +84,14 @@ class HeartbeatManager:
         Resets the heartbeat timer and spawns a new heartbeat loop.
         Should be called after the protocol has reconnected.
         """
+        # Cancel any heartbeat loop still running from the previous connection.
+        # When a drop is detected by the reader loop (not by a heartbeat
+        # timeout/send failure), the old loop is merely asleep and would
+        # otherwise survive the reconnect, leaving two loops running and
+        # accumulating one extra on every reconnect.
+        if self._task_scope is not None:
+            self._task_scope.cancel()
+
         self._last_received = time.monotonic()
         if self._task_group is not None:
             self._task_group.start_soon(self._heartbeat_loop)
@@ -121,5 +129,8 @@ class HeartbeatManager:
                     logger.debug("Heartbeat sent to server")
                 except Exception as e:
                     logger.warning("Failed to send heartbeat: %s", e)
-                    # Protocol will handle reconnection
+                    # A failed write can be the first (or only) sign of a
+                    # half-open connection, so drive reconnection explicitly
+                    # instead of relying on the reader loop to notice.
+                    await self._protocol.handle_disconnect()
                     return

{ctrader_api_client-0.5.0 → ctrader_api_client-0.5.1}/src/ctrader_api_client/connection/protocol.py

@@ -83,6 +83,10 @@ class Protocol:
         self._reconnect_min_wait = reconnect_min_wait
         self._reconnect_max_wait = reconnect_max_wait
 
+        # Guards against multiple concurrent reconnection attempts (e.g. the
+        # reader loop and the heartbeat loop both detecting the same drop).
+        self._reconnecting = False
+
         # Reconnection callback (set by CTraderClient)
         self._on_reconnect: Callable[[], Awaitable[None]] | None = None
 
@@ -314,29 +318,74 @@ class Protocol:
             logger.warning("Event handler error: %s", e)
 
     async def handle_disconnect(self) -> None:
-        """Handle unexpected disconnection and attempt reconnection."""
-        logger.warning("Connection lost, attempting to reconnect...")
+        """Trigger reconnection after an unexpected disconnect.
+
+        Safe to call from any task — the reader loop, the heartbeat loop, or a
+        failed heartbeat write. The reconnection itself runs as a *separate*
+        task on the protocol task group (see :meth:`_reconnect_task`) rather
+        than inline.
+
+        This indirection is essential: the caller is usually the reader loop,
+        which invokes this method from inside its own ``anyio.CancelScope``.
+        Doing the reconnection inline used to cancel that scope (to stop the
+        reader) and thereby abort the in-flight reconnection at its very first
+        checkpoint, leaving the client permanently offline. Spawning a
+        standalone task decouples the reconnection from the cancel scope of
+        whichever loop detected the drop.
+
+        Idempotent: calls made while a reconnection is already in flight are
+        ignored, so the reader and heartbeat loops racing to report the same
+        drop only produce a single reconnection.
+        """
+        if not self._running or self._reconnecting:
+            return
+        if self._task_group is None:
+            return
 
-        # Cancel the reader loop first to prevent race conditions
-        if self._reader_scope is not None:
-            self._reader_scope.cancel()
-            self._reader_scope = None
+        self._reconnecting = True
+        logger.warning("Connection lost, attempting to reconnect...")
+        self._task_group.start_soon(self._reconnect_task)
 
-        # Close the transport
-        await self._transport.close()
+    async def _reconnect_task(self) -> None:
+        """Own the full reconnection lifecycle from a standalone task.
 
-        # Attempt reconnection
+        Runs outside the reader/heartbeat cancel scopes so it survives the death
+        of whichever task detected the drop. It must never let an exception
+        escape: an unhandled error here would propagate into the protocol task
+        group and tear down every other task. A terminal reconnection failure is
+        instead recorded by stopping the protocol and waking pending requests.
+        """
         try:
+            # The reader loop is reading a dead stream; cancel it before we
+            # reconnect so a stale reader can't race the fresh one we restart.
+            if self._reader_scope is not None:
+                self._reader_scope.cancel()
+                self._reader_scope = None
+
+            # Close the old transport (idempotent — the task that detected the
+            # drop may have already raced us to it).
+            await self._transport.close()
+
             await self._reconnect()
             logger.info("Reconnection successful")
         except (CTraderConnectionFailedError, CTraderConnectionClosedError) as e:
-            logger.error("Reconnection failed: %s", e)
+            logger.error("Reconnection failed, giving up: %s", e)
             self._running = False
-            # Signal all pending requests to wake up with error
+            # Wake all pending requests so callers fail fast instead of hanging.
             for msg_id in list(self._pending.keys()):
-                self._errors[msg_id] = CTraderConnectionClosedError("Connection lost and reconnection failed")
+                self._errors[msg_id] = CTraderConnectionClosedError(
+                    "Connection lost and reconnection failed"
+                )
                 self._pending[msg_id].set()
-            raise
+        except Exception:
+            # Defensive: never let the reconnection task crash the task group.
+            logger.exception("Unexpected error while reconnecting")
+            self._running = False
+            for msg_id in list(self._pending.keys()):
+                self._errors[msg_id] = CTraderConnectionClosedError("Reconnection error")
+                self._pending[msg_id].set()
+        finally:
+            self._reconnecting = False
 
     async def _reconnect(self) -> None:
         """Attempt reconnection with exponential backoff.
@@ -369,6 +418,12 @@ class Protocol:
         if self._task_group is not None:
             self._task_group.start_soon(self._reader_loop)
 
-        # Notify callback for re-authentication
+        # Notify callback for re-authentication. The transport is already back
+        # up at this point, so a failure in the callback must not fail the
+        # reconnection itself — log it and let the caller's ReconnectedEvent
+        # surface the details.
         if self._on_reconnect is not None:
-            await self._on_reconnect()
+            try:
+                await self._on_reconnect()
+            except Exception:
+                logger.exception("Post-reconnect re-authentication callback failed")

{ctrader_api_client-0.5.0 → ctrader_api_client-0.5.1}/tests/unit/connection/test_protocol.py

@@ -417,3 +417,86 @@ class TestReconnect:
         await protocol._reconnect()
 
         assert call_count == 3
+
+    @pytest.mark.anyio
+    async def test_reader_triggered_disconnect_actually_reconnects(self, mock_transport: MagicMock) -> None:
+        """Regression: a drop detected by the reader loop must fully reconnect.
+
+        Previously ``handle_disconnect`` ran inline and cancelled the reader
+        loop's own cancel scope, aborting the reconnection at its first
+        checkpoint so the client stayed offline forever.
+        """
+        # The stream reports EOF once (server closed the socket), then blocks so
+        # the restarted reader parks on a healthy connection instead of looping.
+        first_read = True
+
+        async def receive(_num_bytes: int) -> bytes:
+            nonlocal first_read
+            if first_read:
+                first_read = False
+                raise anyio.EndOfStream
+            await anyio.sleep_forever()
+
+        mock_stream = AsyncMock()
+        mock_stream.receive = receive
+        mock_transport.stream = mock_stream
+
+        # close() must contain a real suspension point (the true transport awaits
+        # stream.aclose()). That checkpoint is exactly where the pre-fix,
+        # self-cancelling handle_disconnect got aborted before reaching
+        # _reconnect() — an AsyncMock close() never suspends and would hide the bug.
+        close_calls = 0
+
+        async def close_with_checkpoint() -> None:
+            nonlocal close_calls
+            close_calls += 1
+            await anyio.sleep(0)
+
+        mock_transport.close = close_with_checkpoint
+
+        reconnected = anyio.Event()
+
+        async def on_reconnect() -> None:
+            reconnected.set()
+
+        protocol = Protocol(
+            mock_transport,
+            reconnect_attempts=3,
+            reconnect_min_wait=0.01,
+            reconnect_max_wait=0.02,
+        )
+        protocol._on_reconnect = on_reconnect
+
+        await protocol.start()
+        try:
+            with anyio.fail_after(2):
+                await reconnected.wait()
+
+            assert close_calls >= 1
+            assert mock_transport.connect.await_count >= 1
+            assert protocol._running is True
+            assert protocol._reconnecting is False
+        finally:
+            await protocol.stop()
+
+    @pytest.mark.anyio
+    async def test_handle_disconnect_noop_while_already_reconnecting(self, mock_transport: MagicMock) -> None:
+        """Concurrent disconnect reports collapse into a single reconnection."""
+        protocol = Protocol(mock_transport)
+        protocol._running = True
+        protocol._reconnecting = True
+
+        await protocol.handle_disconnect()
+
+        mock_transport.connect.assert_not_called()
+
+    @pytest.mark.anyio
+    async def test_handle_disconnect_noop_when_not_running(self, mock_transport: MagicMock) -> None:
+        """A disconnect during/after shutdown must not trigger reconnection."""
+        protocol = Protocol(mock_transport)
+        protocol._running = False
+
+        await protocol.handle_disconnect()
+
+        mock_transport.connect.assert_not_called()
+        assert protocol._reconnecting is False

{ctrader_api_client-0.5.0 → ctrader_api_client-0.5.1}/uv.lock

@@ -201,7 +201,7 @@ wheels = [
 
 [[package]]
 name = "ctrader-api-client"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },

ctrader_api_client-0.5.0/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git -C \"/home/tek/Desktop/Algo Trading/Live Trading/cTrader/ctrader-api-client\" log --oneline -10)"
-    ]
-  }
-}