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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrader-api-client
-Version: 0.4.2
+Version: 0.5.0
 Summary: API Client to interact with the cTrader Open API spec
 Author-email: Elio <elioachukri@pm.me>
 License-File: LICENSE
@@ -183,7 +183,7 @@ async def on_spot(event: SpotEvent):
 async def on_execution(event: ExecutionEvent):
     print(f"Order {event.order_id}: {event.execution_type}")
 
-# Account ready (fires on initial auth and after reconnection)
+# Account ready (fires on initial auth, after reconnection, and after account-disconnect recovery)
 @client.on(ReadyEvent)
 async def on_ready(event: ReadyEvent):
     # Set up subscriptions here
@@ -225,6 +225,13 @@ The client automatically handles connection drops:
 3. Emits `ReadyEvent` for each restored account (for resubscribing to market data)
 4. Emits `ReconnectedEvent` with summary of restored/failed accounts
 
+It also handles **server-side account disconnects** (e.g. a broker dropping the
+account session over the weekend while the connection stays up): the account is
+re-authenticated on the existing connection with backoff until it succeeds, then
+a `ReadyEvent` is emitted so subscriptions can be restored. Account
+authorization is observable via `client.is_account_authorized(account_id)`,
+which is distinct from the transport-level `client.is_connected`.
+
 Use `ReadyEvent` to set up subscriptions that persist across reconnections.
 
 ## Configuration

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/README.md

@@ -164,7 +164,7 @@ async def on_spot(event: SpotEvent):
 async def on_execution(event: ExecutionEvent):
     print(f"Order {event.order_id}: {event.execution_type}")
 
-# Account ready (fires on initial auth and after reconnection)
+# Account ready (fires on initial auth, after reconnection, and after account-disconnect recovery)
 @client.on(ReadyEvent)
 async def on_ready(event: ReadyEvent):
     # Set up subscriptions here
@@ -206,6 +206,13 @@ The client automatically handles connection drops:
 3. Emits `ReadyEvent` for each restored account (for resubscribing to market data)
 4. Emits `ReconnectedEvent` with summary of restored/failed accounts
 
+It also handles **server-side account disconnects** (e.g. a broker dropping the
+account session over the weekend while the connection stays up): the account is
+re-authenticated on the existing connection with backoff until it succeeds, then
+a `ReadyEvent` is emitted so subscriptions can be restored. Account
+authorization is observable via `client.is_account_authorized(account_id)`,
+which is distinct from the transport-level `client.is_connected`.
+
 Use `ReadyEvent` to set up subscriptions that persist across reconnections.
 
 ## Configuration

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/docs/api/events.md

@@ -85,7 +85,9 @@ async def on_spot(event: SpotEvent):
     options:
       show_source: false
 
-**Use this to set up subscriptions that persist across reconnections:**
+**Use this to set up subscriptions that persist across reconnections.** It fires
+on initial auth, after a transport reconnection, and after recovery from a
+server-side account disconnect — `is_reconnect` is `True` for the latter two:
 
 ```python
 @client.on(ReadyEvent)
@@ -93,9 +95,19 @@ async def on_ready(event: ReadyEvent):
     await client.market_data.subscribe_spots(event.account_id, [270])
 
     if event.is_reconnect:
-        print("Connection restored!")
+        print("Session restored!")
 ```
 
+`ReadyEvent` emission is driven by why authentication occurred, expressed as an
+`AuthTrigger`. It is emitted for `INITIAL`, `RECONNECT`, and `ACCOUNT_REAUTH`
+(all of which lose or re-establish subscriptions), and suppressed for
+`TOKEN_REFRESH` (session intact).
+
+::: ctrader_api_client.auth.AuthTrigger
+    options:
+      show_source: false
+      members: true
+
 ::: ctrader_api_client.events.TraderUpdateEvent
     options:
       show_source: false
@@ -137,6 +149,11 @@ async def on_reconnected(event: ReconnectedEvent):
     options:
       show_source: false
 
+The client recovers from this automatically — it re-authenticates the account on
+the existing connection with backoff and emits a `ReadyEvent` on success. The
+event is informational; subscribe to it only if you want to observe or log the
+drop. Check current authorization with `client.is_account_authorized(account_id)`.
+
 ::: ctrader_api_client.events.TokenInvalidatedEvent
     options:
       show_source: false

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/docs/getting-started.md

@@ -167,19 +167,26 @@ if __name__ == "__main__":
 
 ## Handling Reconnections
 
-The client automatically reconnects when the connection drops. Use `ReadyEvent` to restore subscriptions:
+The client automatically reconnects when the connection drops, and also recovers
+from server-side account disconnects (where the account session is dropped but
+the connection stays up). In both cases it re-authenticates and emits a
+`ReadyEvent`. Use `ReadyEvent` to restore subscriptions:
 
 ```python
 @client.on(ReadyEvent)
 async def on_ready(event: ReadyEvent):
-    """Called on initial auth AND after reconnection."""
+    """Called on initial auth, after reconnection, and after account recovery."""
     # Set up subscriptions here - they persist across reconnects
     await client.market_data.subscribe_spots(event.account_id, [270, 271, 272])
 
     if event.is_reconnect:
-        print("Connection restored!")
+        print("Session restored!")
 ```
 
+You can check whether an account currently has a live, authorized session with
+`client.is_account_authorized(account_id)` — distinct from the transport-level
+`client.is_connected`.
+
 For additional reconnection information:
 
 ```python

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

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

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/src/ctrader_api_client/__init__.py

@@ -38,6 +38,7 @@ Example:
     ```
 """
 
+from .auth import AuthTrigger
 from .client import CTraderClient
 from .config import ClientConfig
 
@@ -54,6 +55,7 @@ from .enums import (
 
 __all__ = [
     "AccountType",
+    "AuthTrigger",
     "CTraderClient",
     "ClientConfig",
     "ExecutionType",

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/src/ctrader_api_client/auth/__init__.py

@@ -6,9 +6,11 @@ with automatic token refresh management.
 
 from .credentials import AccountCredentials
 from .manager import AuthManager
+from .trigger import AuthTrigger
 
 
 __all__ = [
     "AccountCredentials",
     "AuthManager",
+    "AuthTrigger",
 ]

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/src/ctrader_api_client/auth/manager.py

@@ -30,6 +30,7 @@ from ..exceptions import (
 )
 from ..models import AccountSummary
 from .credentials import AccountCredentials
+from .trigger import AuthTrigger
 
 
 if TYPE_CHECKING:
@@ -39,7 +40,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 TokenRefreshCallback = Callable[[AccountCredentials], Awaitable[None]]
-AccountReadyCallback = Callable[[int, bool, bool], Awaitable[None]]  # (account_id, is_reconnect, is_reauth)
+AccountReadyCallback = Callable[[int, AuthTrigger], Awaitable[None]]  # (account_id, trigger)
 
 
 class AuthManager:
@@ -77,6 +78,8 @@ class AuthManager:
         refresh_retry_attempts: int = 3,
         refresh_retry_min_wait: float = 1.0,
         refresh_retry_max_wait: float = 30.0,
+        reauth_retry_min_wait: float = 1.0,
+        reauth_retry_max_wait: float = 60.0,
         on_tokens_refreshed: TokenRefreshCallback | None = None,
         on_account_ready: AccountReadyCallback | None = None,
     ) -> None:
@@ -96,10 +99,14 @@ class AuthManager:
                 Defaults to 1.0.
             refresh_retry_max_wait: Maximum wait between retries (seconds).
                 Defaults to 30.0.
+            reauth_retry_min_wait: Initial backoff between account recovery
+                re-auth attempts (seconds). Defaults to 1.0.
+            reauth_retry_max_wait: Maximum backoff between account recovery
+                re-auth attempts (seconds). Defaults to 60.0.
             on_tokens_refreshed: Async callback invoked when tokens are refreshed.
                 Receives the new AccountCredentials. Use this to persist tokens.
             on_account_ready: Async callback invoked when an account is authenticated.
-                Receives (account_id, is_reconnect). Use this to perform any initial client setup.
+                Receives (account_id, trigger). Use this to perform any initial client setup.
         """
         self._protocol = protocol
         self._client_id = client_id
@@ -109,12 +116,21 @@ class AuthManager:
         self._retry_attempts = refresh_retry_attempts
         self._retry_min_wait = refresh_retry_min_wait
         self._retry_max_wait = refresh_retry_max_wait
+        self._reauth_retry_min_wait = reauth_retry_min_wait
+        self._reauth_retry_max_wait = reauth_retry_max_wait
         self._on_tokens_refreshed = on_tokens_refreshed
         self._on_account_ready = on_account_ready
 
         # Account storage
         self._accounts: dict[int, AccountCredentials] = {}
 
+        # Accounts with a live, authorized server-side session
+        self._authorized_accounts: set[int] = set()
+
+        # Accounts awaiting recovery re-auth after a server-side disconnect
+        self._pending_reauth: set[int] = set()
+        self._reauth_signal = anyio.Event()
+
         # Background task management
         self._task_group: anyio.abc.TaskGroup | None = None
         self._task_scope: anyio.CancelScope | None = None
@@ -130,9 +146,25 @@ class AuthManager:
 
     @property
     def authenticated_accounts(self) -> list[int]:
-        """List of authenticated account IDs."""
+        """List of account IDs the manager holds credentials for."""
         return list(self._accounts.keys())
 
+    @property
+    def authorized_accounts(self) -> list[int]:
+        """List of account IDs with a live, authorized server-side session."""
+        return list(self._authorized_accounts)
+
+    def is_account_authorized(self, account_id: int) -> bool:
+        """Whether the account currently has a live, authorized session.
+
+        Returns False after a server-side account disconnect until recovery
+        re-authentication succeeds.
+
+        Args:
+            account_id: The cTID trader account ID.
+        """
+        return account_id in self._authorized_accounts
+
     def get_credentials(self, account_id: int) -> AccountCredentials | None:
         """Get credentials for an account.
 
@@ -159,7 +191,7 @@ class AuthManager:
             APIError: If authentication fails.
             CTraderConnectionTimeoutError: If request times out.
         """
-        logger.info("Authenticating application")
+        logger.debug("Authenticating application")
 
         request = ProtoOAApplicationAuthReq(
             client_id=self._client_id,
@@ -175,11 +207,14 @@ class AuthManager:
             )
 
         self._app_authenticated = True
-        logger.info("Application authenticated successfully")
+        logger.debug("Application authenticated successfully")
         return response
 
     async def authenticate_account(
-        self, credentials: AccountCredentials, timeout: float = 30.0, reauth: bool = False, reconnect: bool = False
+        self,
+        credentials: AccountCredentials,
+        timeout: float = 30.0,
+        trigger: AuthTrigger = AuthTrigger.INITIAL,
     ) -> ProtoOAAccountAuthRes:
         """Authenticate a trading account.
 
@@ -188,9 +223,9 @@ class AuthManager:
         Args:
             credentials: The account credentials including tokens.
             timeout: Request timeout in seconds.
-            reauth: Whether this is a re-authentication (token refresh) or initial auth.
-            reconnect: Whether this authentication is happening during a connection reconnect. This can be used
-                to differentiate between a token refresh and a full reconnect scenario in the account ready callback.
+            trigger: Why the authentication is happening. Threaded through to
+                the account-ready callback so subscription restoration can be
+                driven correctly (see AuthTrigger).
 
         Returns:
             The authentication response from the server.
@@ -199,10 +234,10 @@ class AuthManager:
             APIError: If authentication fails.
             CTraderConnectionTimeoutError: If request times out.
         """
-        if reauth:
-            logger.info("Re-authenticating account %d", credentials.account_id)
+        if trigger is AuthTrigger.INITIAL:
+            logger.debug("Authenticating account %d", credentials.account_id)
         else:
-            logger.info("Authenticating account %d", credentials.account_id)
+            logger.debug("Re-authenticating account %d (%s)", credentials.account_id, trigger.value)
 
         request = ProtoOAAccountAuthReq(
             ctid_trader_account_id=credentials.account_id,
@@ -217,14 +252,16 @@ class AuthManager:
                 description=f"Expected ProtoOAAccountAuthRes, got {type(response).__name__}",
             )
 
-        # Store credentials for refresh monitoring
+        # Store credentials for refresh monitoring and mark the session live
         self._accounts[credentials.account_id] = credentials
-        logger.info("Account %d authenticated successfully", credentials.account_id)
+        self._authorized_accounts.add(credentials.account_id)
+        self._pending_reauth.discard(credentials.account_id)
+        logger.debug("Account %d authenticated successfully", credentials.account_id)
 
         # Notify callback
         if self._on_account_ready is not None:
             try:
-                await self._on_account_ready(credentials.account_id, reconnect, reauth)
+                await self._on_account_ready(credentials.account_id, trigger)
             except Exception as e:
                 logger.warning(
                     "Account ready callback failed for account %d: %s",
@@ -339,7 +376,7 @@ class AuthManager:
             APIError: If authentication fails.
             CTraderConnectionTimeoutError: If request times out.
         """
-        logger.info("Authenticating by trader login %d", trader_login)
+        logger.debug("Authenticating by trader login %d", trader_login)
 
         # Resolve trader_login to account_id
         account_id = await self.resolve_account_id(access_token, trader_login, timeout=timeout)
@@ -368,15 +405,42 @@ class AuthManager:
         """
         if account_id in self._accounts:
             del self._accounts[account_id]
-            logger.info("Account %d removed from auth manager", account_id)
+            self._authorized_accounts.discard(account_id)
+            self._pending_reauth.discard(account_id)
+            logger.debug("Account %d removed from auth manager", account_id)
             return True
         return False
 
+    def handle_account_disconnect(self, account_id: int) -> None:
+        """Handle a server-side account disconnect.
+
+        Marks the account's session as no longer authorized and schedules
+        recovery re-authentication on the existing connection. Idempotent while
+        a recovery is already pending for the account.
+
+        Args:
+            account_id: The cTID trader account ID reported as disconnected.
+        """
+        if account_id not in self._accounts:
+            return
+
+        self._authorized_accounts.discard(account_id)
+
+        if account_id in self._pending_reauth:
+            return
+
+        self._pending_reauth.add(account_id)
+        self._reauth_signal.set()
+        logger.warning(
+            "Account %d disconnected by server; scheduling re-authentication",
+            account_id,
+        )
+
     async def start(self) -> None:
-        """Start the token refresh monitor.
+        """Start the background monitors.
 
-        This runs a background task that periodically checks for expiring
-        tokens and refreshes them automatically.
+        Runs the token refresh monitor and the account recovery monitor, which
+        re-authenticates accounts dropped by a server-side disconnect.
         """
         if self._running:
             return
@@ -385,10 +449,11 @@ class AuthManager:
         self._task_group = anyio.create_task_group()
         await self._task_group.__aenter__()
         self._task_group.start_soon(self._refresh_loop)
-        logger.debug("Token refresh monitor started")
+        self._task_group.start_soon(self._reauth_loop)
+        logger.debug("Auth monitors started")
 
     async def stop(self) -> None:
-        """Stop the token refresh monitor."""
+        """Stop the background monitors."""
         self._running = False
 
         if self._task_scope is not None:
@@ -402,7 +467,49 @@ class AuthManager:
                 pass
             self._task_group = None
 
-        logger.debug("Token refresh monitor stopped")
+        self._authorized_accounts.clear()
+        self._pending_reauth.clear()
+
+        logger.debug("Auth monitors stopped")
+
+    async def _reauth_loop(self) -> None:
+        """Recover accounts dropped by a server-side account disconnect.
+
+        Waits for accounts flagged by handle_account_disconnect, then
+        re-authenticates them on the existing connection with capped
+        exponential backoff, retrying indefinitely until each succeeds or the
+        manager stops. A successful re-auth restores authorized state and emits
+        a ReadyEvent so subscriptions can be restored.
+        """
+        while self._running:
+            await self._reauth_signal.wait()
+            self._reauth_signal = anyio.Event()
+
+            backoff = self._reauth_retry_min_wait
+            while self._running and self._pending_reauth:
+                recovered_any = False
+                for account_id in list(self._pending_reauth):
+                    credentials = self._accounts.get(account_id)
+                    if credentials is None:
+                        self._pending_reauth.discard(account_id)
+                        continue
+                    try:
+                        await self.authenticate_account(credentials, trigger=AuthTrigger.ACCOUNT_REAUTH)
+                        recovered_any = True
+                    except Exception as e:
+                        logger.warning(
+                            "Recovery re-authentication for account %d failed, will retry: %s",
+                            account_id,
+                            e,
+                        )
+
+                if not self._pending_reauth:
+                    break
+
+                if recovered_any:
+                    backoff = self._reauth_retry_min_wait
+                await anyio.sleep(backoff)
+                backoff = min(backoff * 2, self._reauth_retry_max_wait)
 
     async def _refresh_loop(self) -> None:
         """Periodically check and refresh expiring tokens."""
@@ -417,7 +524,7 @@ class AuthManager:
                         continue
 
                     if credentials.expires_soon(self._refresh_buffer):
-                        logger.info(
+                        logger.debug(
                             "Token for account %d expires soon (%.0fs remaining), refreshing",
                             account_id,
                             credentials.time_until_expiry(),
@@ -481,14 +588,14 @@ class AuthManager:
                     )
                     self._accounts[account_id] = new_credentials
 
-                    logger.info(
+                    logger.debug(
                         "Token refreshed for account %d, new expiry in %ds",
                         account_id,
                         response.expires_in,
                     )
 
                     # Re-authenticate the account with the new token
-                    await self.authenticate_account(new_credentials, reauth=True)
+                    await self.authenticate_account(new_credentials, trigger=AuthTrigger.TOKEN_REFRESH)
 
                     # Notify callback
                     if self._on_tokens_refreshed is not None:

ctrader_api_client-0.5.0/src/ctrader_api_client/auth/trigger.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class AuthTrigger(Enum):
+    """Reason an account authentication was performed.
+
+    Threaded through account authentication so downstream logic can
+    distinguish cases where the server-side session (and its subscriptions)
+    is lost from cases where it is preserved.
+    """
+
+    INITIAL = "INITIAL"
+    RECONNECT = "RECONNECT"
+    TOKEN_REFRESH = "TOKEN_REFRESH"
+    ACCOUNT_REAUTH = "ACCOUNT_REAUTH"

{ctrader_api_client-0.4.2 → ctrader_api_client-0.5.0}/src/ctrader_api_client/client.py

@@ -5,7 +5,7 @@ from collections.abc import Awaitable, Callable
 from typing import Any, TypeVar, overload
 
 from .api import AccountsAPI, MarketDataAPI, SymbolsAPI, TradingAPI
-from .auth import AuthManager
+from .auth import AuthManager, AuthTrigger
 from .config import ClientConfig
 from .connection import HeartbeatManager, Protocol, Transport
 from .events import (
@@ -170,6 +170,9 @@ class CTraderClient:
         # Set up reconnection handler
         self._protocol._on_reconnect = self._handle_reconnect
 
+        # Recover accounts dropped by a server-side disconnect
+        self._emitter.subscribe(AccountDisconnectEvent, self._handle_account_disconnect)
+
     # -------------------------------------------------------------------------
     # Properties
     # -------------------------------------------------------------------------
@@ -229,9 +232,21 @@ class CTraderClient:
 
     @property
     def is_connected(self) -> bool:
-        """Whether the client is connected to the server."""
+        """Whether the client is connected to the server (transport level)."""
         return self._connected and self._transport.is_connected
 
+    def is_account_authorized(self, account_id: int) -> bool:
+        """Whether the account currently has a live, authorized session.
+
+        Returns False after a server-side account disconnect until recovery
+        re-authentication succeeds. Distinct from is_connected, which only
+        reflects the transport-level connection.
+
+        Args:
+            account_id: The cTID trader account ID.
+        """
+        return self._auth.is_account_authorized(account_id)
+
     @property
     def protocol(self) -> Protocol:
         """Direct access to the protocol layer.
@@ -257,7 +272,7 @@ class CTraderClient:
         if self._connected:
             return
 
-        logger.info("Connecting to %s:%d", self._config.host, self._config.port)
+        logger.debug("Connecting to %s:%d", self._config.host, self._config.port)
 
         await self._transport.connect()
         await self._protocol.start()
@@ -266,7 +281,7 @@ class CTraderClient:
         self._router.start()
 
         self._connected = True
-        logger.info("Connected successfully")
+        logger.info("Connected to cTrader server at %s:%d", self._config.host, self._config.port)
 
     async def close(self) -> None:
         """Close the connection and clean up resources.
@@ -277,7 +292,7 @@ class CTraderClient:
         if not self._connected:
             return
 
-        logger.info("Closing connection")
+        logger.debug("Closing connection")
 
         self._router.stop()
         await self._auth.stop()
@@ -286,26 +301,31 @@ class CTraderClient:
         await self._transport.close()
 
         self._connected = False
-        logger.info("Connection closed")
+        logger.debug("Connection closed")
 
-    async def _emit_ready_event(self, account_id: int, is_reconnect: bool, is_reauth: bool) -> None:
+    async def _emit_ready_event(self, account_id: int, trigger: AuthTrigger) -> None:
         """Emit ReadyEvent when an account is authenticated.
 
-        Called by AuthManager after successful account authentication.
-
-        Does NOT emit if this is a re-auth with no reconnection (e.g. token refresh), since subscriptions
-        are not lost in that case and users don't need to restore them.
+        Called by AuthManager after successful account authentication. Emitted
+        for every authentication that (re)establishes a server-side session and
+        therefore requires subscriptions to be (re)applied: INITIAL, RECONNECT,
+        and ACCOUNT_REAUTH. Suppressed for TOKEN_REFRESH, where the session and
+        its subscriptions remain intact.
 
         Args:
             account_id: The authenticated account ID.
-            is_reconnect: True if this is a re-authentication after reconnection.
+            trigger: Why the authentication occurred.
         """
-        if is_reauth and not is_reconnect:
-            # Don't emit ReadyEvent for token refresh re-auth, since subscriptions are not lost
+        if trigger is AuthTrigger.TOKEN_REFRESH:
             return
 
+        is_reconnect = trigger in (AuthTrigger.RECONNECT, AuthTrigger.ACCOUNT_REAUTH)
         await self._emitter.emit(ReadyEvent(account_id=account_id, is_reconnect=is_reconnect))
 
+    async def _handle_account_disconnect(self, event: AccountDisconnectEvent) -> None:
+        """Route a server-side account disconnect into recovery re-auth."""
+        self._auth.handle_account_disconnect(event.account_id)
+
     async def _handle_reconnect(self) -> None:
         """Handle automatic reconnection by re-authenticating.
 
@@ -313,7 +333,7 @@ class CTraderClient:
         the app and all previously authenticated accounts, then emits
         a ReconnectedEvent so users can restore subscriptions.
         """
-        logger.info("Connection restored, re-authenticating...")
+        logger.debug("Connection restored, re-authenticating...")
 
         # Restart heartbeat monitoring
         await self._heartbeat.restart()
@@ -325,7 +345,7 @@ class CTraderClient:
         try:
             await self._auth.authenticate_app()
             app_auth_restored = True
-            logger.info("App re-authenticated successfully")
+            logger.debug("App re-authenticated successfully")
         except Exception as e:
             logger.error("Failed to re-authenticate app after reconnect: %s", e)
             app_auth_restored = False
@@ -342,9 +362,9 @@ class CTraderClient:
         # Re-authenticate all previously authenticated accounts
         for account_id, credentials in list(self._auth._accounts.items()):
             try:
-                await self._auth.authenticate_account(credentials, reconnect=True)
+                await self._auth.authenticate_account(credentials, trigger=AuthTrigger.RECONNECT)
                 restored.append(account_id)
-                logger.info("Re-authenticated account %d", account_id)
+                logger.debug("Re-authenticated account %d", account_id)
             except Exception as e:
                 logger.error("Failed to re-authenticate account %d: %s", account_id, e)
                 failed.append((account_id, str(e)))

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

@@ -56,7 +56,7 @@ class HeartbeatManager:
         self._task_group = anyio.create_task_group()
         await self._task_group.__aenter__()
         self._task_group.start_soon(self._heartbeat_loop)
-        logger.info("Heartbeat monitor started (interval=%.1fs, timeout=%.1fs)", self._interval, self._timeout)
+        logger.debug("Heartbeat monitor started (interval=%.1fs, timeout=%.1fs)", self._interval, self._timeout)
 
     async def stop(self) -> None:
         """Stop heartbeat monitoring.
@@ -67,7 +67,7 @@ class HeartbeatManager:
             self._task_scope.cancel()
 
         if self._task_group is not None:
-            logger.info("Heartbeat monitor stopped")
+            logger.debug("Heartbeat monitor stopped")
             self._task_group.cancel_scope.cancel()
             try:
                 await self._task_group.__aexit__(None, None, None)
@@ -87,7 +87,7 @@ class HeartbeatManager:
         self._last_received = time.monotonic()
         if self._task_group is not None:
             self._task_group.start_soon(self._heartbeat_loop)
-        logger.info("Heartbeat monitor restarted")
+        logger.debug("Heartbeat monitor restarted")
 
     async def _record_activity(self, _message: betterproto.Message) -> None:
         """Reset the inactivity timer on any received server message."""

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

@@ -358,7 +358,7 @@ class Protocol:
             reraise=True,
         ):
             with attempt:
-                logger.info(
+                logger.debug(
                     "Reconnection attempt %d/%d",
                     attempt.retry_state.attempt_number,
                     self._reconnect_attempts,