test(ibkr): cover account snapshot readiness

Author: brndnmtthws

.pre-commit-config.yaml

@@ -1,13 +1,13 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.3.0
+    rev: v6.0.0
     hooks:
       - id: check-yaml
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.12.5
+    rev: v0.14.4
     hooks:
       # Run the linter.
       - id: ruff-check
@@ -19,13 +19,13 @@ repos:
       - id: ruff-format
   - repo: https://github.com/astral-sh/uv-pre-commit
     # uv version.
-    rev: 0.8.3
+    rev: 0.9.8
     hooks:
       - id: uv-sync
         args: ["--locked", "--all-packages"]
   - repo: https://github.com/astral-sh/uv-pre-commit
     # uv version.
-    rev: 0.8.3
+    rev: 0.9.8
     hooks:
       # Update the uv lockfile
       - id: uv-lock

tests/test_ibkr.py

@@ -1,7 +1,17 @@
 import asyncio
+from types import SimpleNamespace
 
 import pytest
-from ib_async import IB, Contract, Order, OrderStatus, Stock, Ticker, Trade
+from ib_async import (
+    IB,
+    AccountValue,
+    Contract,
+    Order,
+    OrderStatus,
+    Stock,
+    Ticker,
+    Trade,
+)
 
 from thetagang import log
 from thetagang.ibkr import (
@@ -25,6 +35,8 @@ def mock_ib(mocker):
     mock.orderStatusEvent.__iadd__ = mocker.Mock(
         return_value=None
     )  # Allow += operation
+    mock.wrapper = mocker.Mock()
+    mock.wrapper.accountValues = {}
     return mock
 
 
@@ -268,6 +280,7 @@ async def test_refresh_account_updates_uses_timeout_wrapper(ibkr, mocker):
     req_future: asyncio.Future = asyncio.get_running_loop().create_future()
     req_future.set_result(None)
     ibkr.ib.reqAccountUpdatesAsync = mocker.Mock(return_value=req_future)
+    mocker.patch.object(ibkr, "_account_snapshot_ready", side_effect=[False, True])
     await_wrapper = mocker.patch.object(
         ibkr, "_await_with_timeout", new=mocker.AsyncMock(return_value=None)
     )
@@ -317,6 +330,106 @@ async def test_refresh_account_updates_propagates_timeout(ibkr, mocker):
         await ibkr.refresh_account_updates("ACC123")
 
 
+async def test_refresh_account_updates_skips_when_snapshot_ready(ibkr, mocker):
+    """No request issued when account snapshot already populated."""
+    mocker.patch.object(ibkr, "_account_snapshot_ready", return_value=True)
+
+    await ibkr.refresh_account_updates("ACC123")
+
+    ibkr.ib.reqAccountUpdatesAsync.assert_not_called()
+
+
+async def test_refresh_account_updates_allows_timeout_if_data_ready(ibkr, mocker):
+    """A timeout is ignored when snapshot becomes ready while waiting."""
+    mocker.patch.object(ibkr, "_account_snapshot_ready", side_effect=[False, True])
+    ibkr.ib.reqAccountUpdatesAsync = mocker.Mock(return_value=object())
+    mocker.patch.object(
+        ibkr,
+        "_await_with_timeout",
+        new=mocker.AsyncMock(
+            side_effect=IBKRRequestTimeout(
+                "account updates", ibkr.api_response_wait_time
+            )
+        ),
+    )
+
+    await ibkr.refresh_account_updates("ACC123")
+
+    assert ibkr._account_snapshot_ready.call_count == 2
+
+
+async def test_refresh_account_updates_raises_when_snapshot_never_populates(
+    ibkr, mocker
+):
+    """If data never arrives, an IBKRRequestTimeout is raised."""
+    mocker.patch.object(ibkr, "_account_snapshot_ready", return_value=False)
+    ibkr.ib.reqAccountUpdatesAsync = mocker.Mock(return_value=object())
+    mocker.patch.object(
+        ibkr, "_await_with_timeout", new=mocker.AsyncMock(return_value=None)
+    )
+
+    with pytest.raises(IBKRRequestTimeout) as excinfo:
+        await ibkr.refresh_account_updates("ACC123")
+
+    assert "no usable account values" in str(excinfo.value)
+
+
+async def test_account_snapshot_ready_checks_for_non_zero_account_values(ibkr, mock_ib):
+    """Helper returns True only when tracked tags have non-zero data."""
+    mock_ib.wrapper.accountValues = {
+        ("ACC123", "NetLiquidation", "USD", ""): AccountValue(
+            "ACC123", "NetLiquidation", "0", "USD", ""
+        )
+    }
+
+    assert ibkr._account_snapshot_ready("ACC123") is False
+
+    mock_ib.wrapper.accountValues = {
+        ("ACC123", "NetLiquidation", "USD", ""): AccountValue(
+            "ACC123", "NetLiquidation", "100000", "USD", ""
+        )
+    }
+
+    assert ibkr._account_snapshot_ready("ACC123") is True
+
+
+async def test_account_snapshot_ready_ignores_other_accounts_and_tags(ibkr, mock_ib):
+    """Values for other accounts or untracked tags should not mark snapshot ready."""
+    mock_ib.wrapper.accountValues = {
+        ("OTHER", "NetLiquidation", "USD", ""): AccountValue(
+            "OTHER", "NetLiquidation", "100000", "USD", ""
+        ),
+        ("ACC123", "GrossPositionValue", "USD", ""): AccountValue(
+            "ACC123", "GrossPositionValue", "5000", "USD", ""
+        ),
+    }
+
+    assert ibkr._account_snapshot_ready("ACC123") is False
+
+
+async def test_account_snapshot_ready_handles_missing_wrapper_or_values(ibkr, mock_ib):
+    """Return False when wrapper or accountValues are absent."""
+    mock_ib.wrapper.accountValues = {}
+    assert ibkr._account_snapshot_ready("ACC123") is False
+
+    mock_ib.wrapper = None
+    assert ibkr._account_snapshot_ready("ACC123") is False
+
+
+async def test_account_value_has_data_true_for_non_zero_numeric(ibkr):
+    """Helper treats any non-zero numeric string as usable data."""
+    value = AccountValue("ACC123", "NetLiquidation", "123.45", "USD", "")
+    assert ibkr._account_value_has_data(value) is True
+
+
+@pytest.mark.parametrize("raw_value", ["0", "0.0", "", None, "abc"])
+async def test_account_value_has_data_false_for_invalid_inputs(ibkr, raw_value):
+    """Helper rejects zero, empty, None, and non-numeric values."""
+    value = SimpleNamespace(value=raw_value)
+
+    assert ibkr._account_value_has_data(value) is False
+
+
 async def test_await_with_timeout_wraps_timeout_error(ibkr, mocker):
     """_await_with_timeout raises IBKRRequestTimeout on asyncio timeout."""
 

thetagang/ibkr.py

@@ -49,6 +49,8 @@ def __init__(self, description: str, timeout_seconds: int) -> None:
 
 
 class IBKR:
+    ACCOUNT_VALUE_HEALTH_TAGS = {"NetLiquidation", "TotalCashValue", "BuyingPower"}
+
     def __init__(
         self, ib: IB, api_response_wait_time: int, default_order_exchange: str
     ) -> None:
@@ -93,9 +95,29 @@ def cancel_order(self, order: Order) -> None:
         self.ib.cancelOrder(order)
 
     async def refresh_account_updates(self, account: str) -> None:
-        await self._await_with_timeout(
-            self.ib.reqAccountUpdatesAsync(account), "account updates"
-        )
+        if self._account_snapshot_ready(account):
+            log.info(
+                f"{account}: Account snapshot already populated, skipping refresh wait."
+            )
+            return
+
+        try:
+            await self._await_with_timeout(
+                self.ib.reqAccountUpdatesAsync(account), "account updates"
+            )
+        except IBKRRequestTimeout:
+            if self._account_snapshot_ready(account):
+                log.info(
+                    f"{account}: Account snapshot populated while waiting for account updates."
+                )
+                return
+            raise
+
+        if not self._account_snapshot_ready(account):
+            raise IBKRRequestTimeout(
+                "account updates (no usable account values)",
+                self.api_response_wait_time,
+            )
 
     async def refresh_positions(self) -> List[Position]:
         return await self._await_with_timeout(
@@ -280,6 +302,39 @@ async def _await_with_timeout(self, awaitable: Awaitable[T], description: str) -
         except asyncio.TimeoutError as exc:
             raise IBKRRequestTimeout(description, self.api_response_wait_time) from exc
 
+    def _account_snapshot_ready(self, account: str) -> bool:
+        """Return True if IB has populated non-zero account values for account."""
+        wrapper = getattr(self.ib, "wrapper", None)
+        if wrapper is None:
+            return False
+
+        values_dict = getattr(wrapper, "accountValues", None)
+        if not values_dict:
+            return False
+
+        for value in values_dict.values():
+            if (
+                value.account != account
+                or value.tag not in self.ACCOUNT_VALUE_HEALTH_TAGS
+            ):
+                continue
+
+            if self._account_value_has_data(value):
+                return True
+
+        return False
+
+    @staticmethod
+    def _account_value_has_data(value: AccountValue) -> bool:
+        raw_value = getattr(value, "value", None)
+        if raw_value in (None, ""):
+            return False
+
+        try:
+            return float(raw_value) != 0.0
+        except (TypeError, ValueError):
+            return False
+
     async def __market_data_streaming_handler__(
         self,
         contract: Contract,