ctrader-api-client 0.7.1__tar.gz → 0.7.2__tar.gz

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/.gitignore

@@ -12,6 +12,10 @@ wheels/
 # IDE-specific files
 .idea/
 .vscode/
+
 # Test artifacts
 .coverage
 .pytest_cache/
+
+# Built documentation
+site/

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/PKG-INFO

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

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/docs/api/events.md

@@ -161,10 +161,22 @@ drop. Check current authorization with `client.is_account_authorized(account_id)
 
 A disconnect the server reports is checked before it is published. Rotating an
 access token makes the server report one for a session it has not ended, so the
-client re-authenticates to find out which it is: an account that still holds its
-session is refused as already authorized, and nothing is published. What reaches
-a handler is therefore always a session that was really gone at the moment it
-was checked.
+client asks whether the account is still served on this connection: if it is,
+nothing is published. The check does not re-authenticate, because that answers
+for the token as much as for the session, and the rotation prompting the report
+is the very thing that would make such an answer unreliable.
+
+The check also waits for any token refresh on that account to finish first.
+Rotating a token means the server drops the old authorization and the client
+establishes a new one, and in between the account is genuinely unauthorized — it
+refuses everything, including the check. Since the refresh always begins before
+the report it provokes, waiting for it to settle is what keeps a moment the
+client itself created from reading as a lost session.
+
+A check that cannot be completed — a timeout, a link that has just gone — is not
+read as a disconnect either. The account is left as it was, and the next report
+is checked afresh. What reaches a handler is therefore always a session the
+server confirmed it was no longer serving.
 
 ::: ctrader_api_client.events.TokenInvalidatedEvent
     options:

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/pyproject.toml

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

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/src/ctrader_api_client/auth/_recovery.py

@@ -104,14 +104,32 @@ class SessionRecovery:
         unauthorized and publish a drop that never occurred, so the report is
         checked against the server before anything acts on it.
 
-        Re-authenticating is the check: a session that is already live is
-        refused with `ALREADY_LOGGED_IN`, which says the report was spurious and
-        there is nothing to tell anyone. Any other answer means the session
-        really did end, and only then is the drop published and recovery armed.
+        Every report the server sends for a token rotation arrives while the
+        client is replacing that authorization, and for the length of that
+        replacement the account really is unauthorized: it answers nothing, and
+        asking it anything would only confirm a state the client is already
+        undoing. So the check waits for the refresh to settle before it asks.
+        The refresh always starts before the report it provokes, so there is no
+        ordering in which the report escapes the wait.
+
+        The check itself asks whether the account is still served on this link
+        rather than trying to re-authorize it, since re-authorizing answers for
+        the token as much as for the session.
+
+        A check that cannot be completed is not an answer of no. The account is
+        left as it was, because nothing has said the session ended.
 
         Args:
             account_id: The cTID trader account ID reported as disconnected.
         """
+        if self._store.is_refreshing(account_id):
+            logger.debug(
+                "Account %d was reported as disconnected while its token was being "
+                "refreshed; waiting for that to settle before checking",
+                account_id,
+            )
+            await self._store.wait_for_refresh(account_id)
+
         credentials = self._store.credentials(account_id)
         if credentials is None or not self._store.is_authorized(account_id):
             return
@@ -121,30 +139,36 @@ class SessionRecovery:
 
         self._verifying.add(account_id)
         try:
-            await self._authenticator.establish(credentials, AuthTrigger.ACCOUNT_REAUTH)
-        except AccountAuthError as e:
-            if e.is_already_authorized():
+            try:
+                alive = await self._authenticator.probe_session(account_id)
+            except Exception as e:
+                logger.debug(
+                    "Could not check the disconnect reported for account %d, leaving it as it is: %s",
+                    account_id,
+                    e,
+                )
+                return
+
+            if alive:
                 logger.debug(
                     "Account %d reported as disconnected still holds its session; ignoring",
                     account_id,
                 )
                 return
-            await self._report_dropped(account_id, e)
-        except Exception as e:
-            await self._report_dropped(account_id, e)
+
+            await self._report_dropped(account_id)
         finally:
             self._verifying.discard(account_id)
 
-    async def _report_dropped(self, account_id: int, error: Exception) -> None:
+    async def _report_dropped(self, account_id: int) -> None:
         """Publish a confirmed drop and arm recovery for it.
 
-        Reached once the server has refused to re-authorize the account, so the
-        session is genuinely gone and could not be re-established on the spot.
+        Reached once the server has stopped serving the account on this link, so
+        the session is genuinely gone.
         """
         logger.warning(
-            "Account %d disconnected by server; scheduling re-authentication: %s",
+            "Account %d disconnected by server; scheduling re-authentication",
             account_id,
-            error,
         )
         self._store.flag_for_recovery(account_id)
         self._reauth_signal.set()

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/src/ctrader_api_client/auth/_refresh.py

@@ -142,6 +142,11 @@ class TokenRefresher:
 
         last_error: Exception | None = None
 
+        # Held from before the request goes out until the account is authorized
+        # again, because the disconnect the server reports for the old token
+        # arrives inside that window and means nothing about the session.
+        self._store.begin_refresh(account_id)
+
         try:
             async for attempt in AsyncRetrying(
                 stop=stop_after_attempt(self._policy.retry_attempts),
@@ -198,6 +203,8 @@ class TokenRefresher:
             last_error = e
         except Exception as e:
             last_error = e
+        finally:
+            self._store.end_refresh(account_id)
 
         if last_error is not None:
             raise TokenRefreshError(account_id, last_error)

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/src/ctrader_api_client/auth/_session.py

@@ -17,6 +17,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Protocol as TypingProtocol
 
+import anyio
+
 from ..enums import AuthTrigger
 from .credentials import AccountCredentials
 
@@ -77,6 +79,15 @@ class SessionAuthenticator(TypingProtocol):
         """Authorize an account, recording why so the right events follow."""
         ...
 
+    async def probe_session(self, account_id: int, timeout: float = 10.0) -> bool:
+        """Whether the account still holds a live session on this link.
+
+        Raises whatever stopped the question from being answered — including a
+        refusal that is about the token rather than the session — which is not
+        the same as an answer of no.
+        """
+        ...
+
 
 class SessionStore:
     """Every account the client knows about, keyed by cTID trader account ID.
@@ -90,6 +101,33 @@ class SessionStore:
     def __init__(self) -> None:
         self._accounts: dict[int, TrackedAccount] = {}
 
+        # Accounts whose authorization is being replaced by a token refresh.
+        # The server drops the old authorization as it issues the new pair, so
+        # for that stretch the account is genuinely unauthorized and answers
+        # nothing — a state no observer should mistake for a lost session.
+        self._refreshing: dict[int, anyio.Event] = {}
+
+    def begin_refresh(self, account_id: int) -> None:
+        """Note that the account's authorization is being replaced."""
+        if account_id not in self._refreshing:
+            self._refreshing[account_id] = anyio.Event()
+
+    def end_refresh(self, account_id: int) -> None:
+        """Note that it has been replaced, or that the attempt gave up."""
+        settled = self._refreshing.pop(account_id, None)
+        if settled is not None:
+            settled.set()
+
+    def is_refreshing(self, account_id: int) -> bool:
+        """Whether a refresh is currently replacing the account's authorization."""
+        return account_id in self._refreshing
+
+    async def wait_for_refresh(self, account_id: int) -> None:
+        """Wait until no refresh is replacing the account's authorization."""
+        settled = self._refreshing.get(account_id)
+        if settled is not None:
+            await settled.wait()
+
     def account_ids(self) -> list[int]:
         """Every account held, oldest first."""
         return list(self._accounts)

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/src/ctrader_api_client/auth/manager.py

@@ -15,6 +15,8 @@ from .._internal.proto import (
     ProtoOAAccountAuthRes,
     ProtoOAApplicationAuthReq,
     ProtoOAApplicationAuthRes,
+    ProtoOATraderReq,
+    ProtoOATraderRes,
 )
 from ..enums import AuthTrigger
 from ..events import EventPublisher, ReadyEvent
@@ -238,6 +240,43 @@ class AuthManager:
                 await self._restorer.restore(credentials.account_id)
             await self._publisher.emit(ReadyEvent(account_id=credentials.account_id, trigger=trigger))
 
+    async def probe_session(self, account_id: int, timeout: float = 10.0) -> bool:
+        """Whether the account still holds a live session on this link.
+
+        Asks the server for something only an authorized account is told. The
+        request carries no access token of its own, but the authorization behind
+        it does: while a rotation is in flight the server refuses everything for
+        the account, including this. That refusal names the token, and it is
+        raised rather than answered, because it says nothing about the session.
+
+        Args:
+            account_id: The cTID trader account ID.
+            timeout: Request timeout in seconds.
+
+        Returns:
+            True if the server still serves the account on this link.
+
+        Raises:
+            APIError: If the refusal is about the token rather than the account.
+            CTraderConnectionTimeoutError: If the request times out.
+            CTraderConnectionClosedError: If the link is gone.
+        """
+        request = ProtoOATraderReq(ctid_trader_account_id=account_id)
+
+        try:
+            await self._protocol.request(request, ProtoOATraderRes, timeout=timeout)
+        except APIError as e:
+            logger.debug(
+                "Account %d was refused a trader lookup: %s (%s)",
+                account_id,
+                e.error_code,
+                e.description,
+            )
+            if e.is_token_failure():
+                raise
+            return False
+        return True
+
     def remove_account(self, account_id: int) -> bool:
         """Remove an account from refresh monitoring.
 

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/tests/behavior/auth/test_token_lifecycle.py

@@ -4,14 +4,19 @@ from __future__ import annotations
 
 from collections.abc import Callable
 
+import anyio
 import betterproto
 import pytest
 
-from ctrader_api_client._internal.proto import ProtoOAAccountAuthReq, ProtoOARefreshTokenReq
+from ctrader_api_client._internal.proto import (
+    ProtoOAAccountAuthReq,
+    ProtoOARefreshTokenReq,
+    ProtoOATraderReq,
+)
 from ctrader_api_client.auth import AuthManager, ReauthPolicy, SessionRecovery, SessionStore
 from ctrader_api_client.enums import AuthTrigger
 from ctrader_api_client.events import AccountDisconnectEvent, ReadyEvent, TokenRefreshFailedEvent
-from ctrader_api_client.exceptions import APIError, TokenExpiredError
+from ctrader_api_client.exceptions import APIError, CTraderConnectionTimeoutError, TokenExpiredError
 
 from ...harness import ManualClock, RecordingPublisher, RecordingStore, StubProtocol, factories
 from .conftest import Monitors
@@ -304,6 +309,7 @@ async def test_an_account_the_server_confirms_is_gone_stops_being_authorized(
         ProtoOAAccountAuthReq,
         [factories.account_auth_res(), APIError(error_code="TEMPORARY")],
     )
+    protocol.respond(ProtoOATraderReq, APIError(error_code="ACCOUNT_NOT_AUTHORIZED"))
     await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
     await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED)
 
@@ -325,14 +331,11 @@ async def test_a_session_the_server_still_holds_is_left_alone(
     Regression guard: taking that report at face value marked a working account
     unauthorized, published a drop that never happened, and left recovery
     retrying an account the server would only ever refuse as already logged in.
+    Checking it by re-authorizing was no better, because the rotation that
+    prompts the report is what makes that check answer wrongly.
     """
-    protocol.respond_in_sequence(
-        ProtoOAAccountAuthReq,
-        [
-            factories.account_auth_res(),
-            APIError(error_code="ALREADY_LOGGED_IN", description="Trading account is already authorized"),
-        ],
-    )
+    protocol.respond(ProtoOAAccountAuthReq, factories.account_auth_res())
+    protocol.respond(ProtoOATraderReq, factories.trader_res())
     await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
     await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED)
 
@@ -341,6 +344,98 @@ async def test_a_session_the_server_still_holds_is_left_alone(
     assert auth.is_account_authorized(factories.ACCOUNT_ID)
     assert publisher.of(AccountDisconnectEvent) == []
     assert publisher.of(ReadyEvent) == [ReadyEvent(factories.ACCOUNT_ID, AuthTrigger.INITIAL)]
+    # Nothing re-authorized the account, so nothing could have disturbed the
+    # session the report was wrong about.
+    assert len(protocol.sent_of(ProtoOAAccountAuthReq)) == 1
+
+
+async def test_a_check_that_cannot_be_answered_leaves_the_account_alone(
+    auth: AuthManager,
+    monitors: Monitors,
+    protocol: StubProtocol,
+    clock: ManualClock,
+    publisher: RecordingPublisher,
+) -> None:
+    """Failing to ask is not the same as being told the session is gone.
+
+    Regression guard: anything that stopped the check from completing used to
+    count as confirmation, so a report that could not be checked took a working
+    account out of service.
+    """
+    protocol.respond(ProtoOAAccountAuthReq, factories.account_auth_res())
+    protocol.respond(ProtoOATraderReq, CTraderConnectionTimeoutError(10.0, "request"))
+    await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
+    await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED)
+
+    await monitors.recovery.handle_account_disconnect(factories.ACCOUNT_ID)
+
+    assert auth.is_account_authorized(factories.ACCOUNT_ID)
+    assert publisher.of(AccountDisconnectEvent) == []
+
+
+async def test_a_disconnect_reported_while_the_token_rotates_is_not_a_drop(
+    auth: AuthManager,
+    monitors: Monitors,
+    protocol: StubProtocol,
+    clock: ManualClock,
+    publisher: RecordingPublisher,
+    sessions: SessionStore,
+) -> None:
+    """The window a refresh opens is not a session anyone lost.
+
+    Regression guard: the server reports a disconnect for the authorization a
+    rotation replaces, and while the replacement is in flight the account is
+    genuinely unauthorized — it refuses everything with INVALID_REQUEST. Asking
+    it anything in that window and believing the answer published a drop for a
+    session that was serving requests a moment later.
+    """
+    protocol.respond(ProtoOAAccountAuthReq, factories.account_auth_res())
+    protocol.respond(ProtoOATraderReq, APIError(error_code="INVALID_REQUEST"))
+    await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
+    await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED)
+    sessions.begin_refresh(factories.ACCOUNT_ID)
+
+    async with anyio.create_task_group() as task_group:
+        task_group.start_soon(monitors.recovery.handle_account_disconnect, factories.ACCOUNT_ID)
+        await anyio.sleep(0.01)
+        # Nothing has been decided while the rotation is in flight.
+        assert publisher.of(AccountDisconnectEvent) == []
+        assert not protocol.sent_of(ProtoOATraderReq)
+
+        protocol.respond(ProtoOATraderReq, factories.trader_res())
+        sessions.end_refresh(factories.ACCOUNT_ID)
+
+    assert auth.is_account_authorized(factories.ACCOUNT_ID)
+    assert publisher.of(AccountDisconnectEvent) == []
+    assert len(protocol.sent_of(ProtoOATraderReq)) == 1
+
+
+@pytest.mark.parametrize("error_code", ["OA_AUTH_TOKEN_EXPIRED", "CH_ACCESS_TOKEN_INVALID"])
+async def test_a_check_refused_over_the_token_leaves_the_account_alone(
+    error_code: str,
+    auth: AuthManager,
+    monitors: Monitors,
+    protocol: StubProtocol,
+    clock: ManualClock,
+    publisher: RecordingPublisher,
+) -> None:
+    """A refusal naming the token says nothing about the session behind it.
+
+    Regression guard: the server refuses everything for an account while a
+    rotation is in flight, and the disconnect it reports for that same rotation
+    arrives inside the window. Reading the refusal as an answer published a drop
+    for a session that was still being served.
+    """
+    protocol.respond(ProtoOAAccountAuthReq, factories.account_auth_res())
+    protocol.respond(ProtoOATraderReq, APIError(error_code=error_code))
+    await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
+    await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED)
+
+    await monitors.recovery.handle_account_disconnect(factories.ACCOUNT_ID)
+
+    assert auth.is_account_authorized(factories.ACCOUNT_ID)
+    assert publisher.of(AccountDisconnectEvent) == []
+    assert len(protocol.sent_of(ProtoOAAccountAuthReq)) == 1
 
 
 async def test_a_disconnected_account_is_re_authenticated(
@@ -351,6 +446,7 @@ async def test_a_disconnected_account_is_re_authenticated(
     publisher: RecordingPublisher,
 ) -> None:
     await start_with_account(auth, protocol, clock, expires_in=PLENTY_OF_TIME)
+    protocol.respond(ProtoOATraderReq, APIError(error_code="ACCOUNT_NOT_AUTHORIZED"))
 
     await monitors.recovery.handle_account_disconnect(factories.ACCOUNT_ID)
     await publisher.wait_for_type(ReadyEvent, count=2)
@@ -370,12 +466,13 @@ async def test_recovery_keeps_trying_after_a_failure(
         ProtoOAAccountAuthReq,
         [
             factories.account_auth_res(),
-            # The check that confirms the drop, then the first retry after it.
-            APIError(error_code="TEMPORARY"),
+            # The first recovery attempt after the drop is confirmed, then the
+            # retry that succeeds.
             APIError(error_code="TEMPORARY"),
             factories.account_auth_res(),
         ],
     )
+    protocol.respond(ProtoOATraderReq, APIError(error_code="ACCOUNT_NOT_AUTHORIZED"))
     await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
     await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED)
 
@@ -393,6 +490,7 @@ async def test_an_account_dropped_during_another_backoff_is_recovered_at_once(
     make_monitors: Callable[..., Monitors],
     protocol: StubProtocol,
     clock: ManualClock,
+    publisher: RecordingPublisher,
 ) -> None:
     """Backoff is per account, so a healthy account never queues behind a sick one."""
     stubborn = 111
@@ -411,12 +509,16 @@ async def test_an_account_dropped_during_another_backoff_is_recovered_at_once(
         return factories.account_auth_res()
 
     protocol.respond_with(ProtoOAAccountAuthReq, answer)
+    # Both reports are real: the server no longer serves either account.
+    protocol.respond(ProtoOATraderReq, APIError(error_code="ACCOUNT_NOT_AUTHORIZED"))
 
     await monitors.recovery.handle_account_disconnect(stubborn)
     # Its failed attempt parks recovery on a ten second backoff.
     await clock.wait_for_sleepers(SLEEPERS_WHEN_STARTED + 1)
 
     await monitors.recovery.handle_account_disconnect(healthy)
+    # Recovery re-authorizes it without waiting out the stubborn account's backoff.
+    await publisher.wait_for_type(ReadyEvent, count=3)
 
     assert auth.is_account_authorized(healthy)
     assert not auth.is_account_authorized(stubborn)
@@ -450,16 +552,14 @@ async def test_a_report_for_an_account_already_recovering_is_not_checked_again(
     indistinguishable from a second check of the same report.
     """
     recovery = SessionRecovery(store=sessions, authenticator=auth, publisher=publisher, clock=clock)
-    protocol.respond_in_sequence(
-        ProtoOAAccountAuthReq,
-        [factories.account_auth_res(), APIError(error_code="TEMPORARY")],
-    )
+    protocol.respond(ProtoOAAccountAuthReq, factories.account_auth_res())
+    protocol.respond(ProtoOATraderReq, APIError(error_code="ACCOUNT_NOT_AUTHORIZED"))
     await auth.authenticate_trader(factories.credentials(expires_in=PLENTY_OF_TIME))
 
     await recovery.handle_account_disconnect(factories.ACCOUNT_ID)
-    checked = len(protocol.sent_of(ProtoOAAccountAuthReq))
+    checked = len(protocol.sent_of(ProtoOATraderReq))
     await recovery.handle_account_disconnect(factories.ACCOUNT_ID)
     await recovery.handle_account_disconnect(factories.ACCOUNT_ID)
 
-    assert len(protocol.sent_of(ProtoOAAccountAuthReq)) == checked
+    assert len(protocol.sent_of(ProtoOATraderReq)) == checked
     assert publisher.of(AccountDisconnectEvent) == [AccountDisconnectEvent(factories.ACCOUNT_ID)]

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/tests/behavior/test_client.py

@@ -14,6 +14,7 @@ from ctrader_api_client._internal.proto import (
     ProtoOAAccountDisconnectEvent,
     ProtoOAApplicationAuthReq,
     ProtoOARefreshTokenReq,
+    ProtoOATraderReq,
 )
 from ctrader_api_client.auth import AccountCredentials
 from ctrader_api_client.events import (
@@ -383,6 +384,8 @@ async def test_an_account_the_server_drops_is_re_authenticated(
     await authenticate(client, server)
     ready: Recorder[ReadyEvent] = Recorder()
     client.register_handler(ReadyEvent, ready)
+    # The server stands behind the report: it will not answer for the account.
+    server.on(ProtoOATraderReq, rejecting)
 
     await server.push(ProtoOAAccountDisconnectEvent(ctid_trader_account_id=factories.ACCOUNT_ID))
     await ready.wait_for(1)
@@ -398,6 +401,7 @@ async def test_a_dropped_account_stays_unauthorized_until_recovery_succeeds(
     await authenticate(client, server)
     dropped: Recorder[AccountDisconnectEvent] = Recorder()
     client.register_handler(AccountDisconnectEvent, dropped)
+    server.on(ProtoOATraderReq, rejecting)
     server.on(ProtoOAAccountAuthReq, rejecting)
 
     await server.push(ProtoOAAccountDisconnectEvent(ctid_trader_account_id=factories.ACCOUNT_ID))
@@ -419,14 +423,16 @@ async def test_a_disconnect_the_server_does_not_stand_behind_is_not_published(
     ready: Recorder[ReadyEvent] = Recorder()
     client.register_handler(AccountDisconnectEvent, dropped)
     client.register_handler(ReadyEvent, ready)
-    server.on(ProtoOAAccountAuthReq, already_logged_in)
+    server.respond(ProtoOATraderReq, factories.trader_res())
 
     await server.push(ProtoOAAccountDisconnectEvent(ctid_trader_account_id=factories.ACCOUNT_ID))
-    await server.wait_for_request(ProtoOAAccountAuthReq, count=2)
+    await server.wait_for_request(ProtoOATraderReq)
 
     assert dropped.count == 0
     assert ready.count == 0
     assert client.is_account_authorized(factories.ACCOUNT_ID) is True
+    # The account was never re-authorized, only asked after.
+    assert len(server.requests_of(ProtoOAAccountAuthReq)) == 1
 
 
 # -----------------------------------------------------------------------------

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/tests/harness/factories.py

@@ -16,6 +16,8 @@ from ctrader_api_client._internal.proto import (
     ProtoOAGetAccountListByAccessTokenRes,
     ProtoOARefreshTokenRes,
     ProtoOASpotEvent,
+    ProtoOATrader,
+    ProtoOATraderRes,
     ProtoOATrendbar,
 )
 from ctrader_api_client.auth import AccountCredentials
@@ -57,6 +59,14 @@ def account_auth_res(account_id: int = ACCOUNT_ID) -> ProtoOAAccountAuthRes:
     return ProtoOAAccountAuthRes(ctid_trader_account_id=account_id)
 
 
+def trader_res(account_id: int = ACCOUNT_ID) -> ProtoOATraderRes:
+    """A successful trader lookup, which only an authorized account is given."""
+    return ProtoOATraderRes(
+        ctid_trader_account_id=account_id,
+        trader=ProtoOATrader(ctid_trader_account_id=account_id),
+    )
+
+
 def ctid_account(
     account_id: int = ACCOUNT_ID,
     trader_login: int = TRADER_LOGIN,

{ctrader_api_client-0.7.1 → ctrader_api_client-0.7.2}/uv.lock

@@ -270,7 +270,7 @@ wheels = [
 
 [[package]]
 name = "ctrader-api-client"
-version = "0.7.1"
+version = "0.7.2"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },