xtb-api-python 0.5.3__tar.gz → 0.5.4__tar.gz

{xtb_api_python-0.5.3 → xtb_api_python-0.5.4}/CHANGELOG.md

@@ -1,6 +1,35 @@
 # CHANGELOG
 
 
+## v0.5.4 (2026-04-15)
+
+### Bug Fixes
+
+- **ws**: Revert get_positions to reqId-based send
+  ([#9](https://github.com/liskeee/xtb-api-unofficial-python/pull/9),
+  [`d197b08`](https://github.com/liskeee/xtb-api-unofficial-python/commit/d197b08350e57a46b82adee5dcb206b2d068b852))
+
+v0.5.3's push-channel collection was based on a wrong diagnosis. Live API probing confirms the
+  xStation5 CoreAPI echoes getPositions on the NORMAL reqId response channel (status=0,
+  response=[...]), not as push events. The original implementation was correct.
+
+The 30s timeouts observed on the original 0.5.2 bot were something else — probably container-level
+  networking / first-call timing — not a protocol mismatch. The wrong fix in 0.5.3 made the problem
+  worse because get_positions() started returning [] instantly, causing the downstream bot to
+  auto-close positions it mistakenly thought were gone from the broker.
+
+Reverts the get_positions implementation to: res = await self.send("getPositions",
+  {"getAndSubscribeElement": {"eid": POSITIONS}}, timeout_ms=30000) return
+  parse_positions(self._extract_elements(res))
+
+Keeps `parse_position_trade` helper in parsers.py — harmless refactor. Removes
+  tests/test_get_positions_push.py — tested wrong behavior.
+
+Verified against real XTB account: all 5 open positions returned in ~1-2s via normal reqId response.
+
+Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
+
+
 ## v0.5.3 (2026-04-15)
 
 ### Bug Fixes

{xtb_api_python-0.5.3 → xtb_api_python-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtb-api-python
-Version: 0.5.3
+Version: 0.5.4
 Summary: Python port of unofficial XTB xStation5 API client
 Project-URL: Homepage, https://github.com/liskeee/xtb-api-python
 Project-URL: Repository, https://github.com/liskeee/xtb-api-python

{xtb_api_python-0.5.3 → xtb_api_python-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xtb-api-python"
-version = "0.5.3"
+version = "0.5.4"
 description = "Python port of unofficial XTB xStation5 API client"
 readme = "README.md"
 license = "MIT"

{xtb_api_python-0.5.3 → xtb_api_python-0.5.4}/src/xtb_api/ws/ws_client.py

@@ -52,7 +52,7 @@ from xtb_api.ws.parsers import (
     parse_balance,
     parse_instruments,
     parse_orders,
-    parse_position_trade,
+    parse_positions,
     parse_quote,
 )
 
@@ -533,81 +533,21 @@ class XTBWebSocketClient:
 
         return parse_balance(self._extract_elements(res), account.currency, account.accountNo)
 
-    async def get_positions(
-        self,
-        *,
-        max_wait_ms: int = 5000,
-        quiet_ms: int = 500,
-    ) -> list[Position]:
+    async def get_positions(self) -> list[Position]:
         """Get all open trading positions.
 
-        XTB's xStation5 CoreAPI returns position data via the push/events
-        channel (`status=1` with `eid=POSITIONS`), NOT via the normal
-        `reqId`-echoed response channel. So we subscribe, then collect the
-        burst of push events that follow, rather than awaiting a direct reply.
-
-        The collection window closes when either:
-        * `max_wait_ms` has elapsed since the subscription fired, OR
-        * `quiet_ms` has passed with no new position push (whichever first).
-
-        Deduplicates by `positionId` so a retriggered snapshot + update sequence
-        won't produce duplicates.
+        XTB's xStation5 CoreAPI echoes the position snapshot on the normal
+        reqId-correlated response channel (not the push channel, despite the
+        `getAndSubscribeElement` keyword). The subscription it sets up also
+        emits per-position updates via `_emit("position", ...)`; those are
+        orthogonal to the snapshot returned here.
         """
-        if not self.is_connected or not self._ws:
-            raise XTBConnectionError("Not connected")
-
-        collected: dict[str, Position] = {}
-        loop = asyncio.get_running_loop()
-        last_push_ts = loop.time()
-
-        def on_position(trade: dict[str, Any]) -> None:
-            nonlocal last_push_ts
-            try:
-                pos = parse_position_trade(trade)
-            except Exception as exc:  # pragma: no cover — defensive
-                logger.warning("Failed to parse position push: %s", exc)
-                return
-            # Dedup by positionId; fall back to object id if missing.
-            key = pos.order_id or str(id(trade))
-            collected[key] = pos
-            last_push_ts = loop.time()
-
-        self.on("position", on_position)
-        try:
-            # Fire the subscribe; do NOT await a reqId response (XTB doesn't
-            # echo one for POSITIONS). The handler above captures the pushes.
-            req_id = self._next_req_id("getPositions")
-            request = {
-                "reqId": req_id,
-                "command": [
-                    {
-                        "CoreAPI": {
-                            "endpoint": self._config.endpoint,
-                            "accountId": self.account_id,
-                            "getAndSubscribeElement": {"eid": SubscriptionEid.POSITIONS},
-                        }
-                    }
-                ],
-            }
-            await self._ws.send(json.dumps(request))
-
-            start = loop.time()
-            max_wait_s = max_wait_ms / 1000.0
-            quiet_s = quiet_ms / 1000.0
-            while True:
-                await asyncio.sleep(0.05)
-                elapsed = loop.time() - start
-                if elapsed >= max_wait_s:
-                    break
-                # Quiet-period exit only after we have at least one position —
-                # otherwise a slow server that hasn't sent anything yet would
-                # trigger the quiet-exit prematurely.
-                if collected and (loop.time() - last_push_ts) >= quiet_s:
-                    break
-        finally:
-            self.off("position", on_position)
-
-        return list(collected.values())
+        res = await self.send(
+            "getPositions",
+            {"getAndSubscribeElement": {"eid": SubscriptionEid.POSITIONS}},
+            timeout_ms=30000,
+        )
+        return parse_positions(self._extract_elements(res))
 
     async def get_orders(self) -> list[PendingOrder]:
         """Get all pending (limit/stop) orders."""

xtb_api_python-0.5.3/tests/test_get_positions_push.py

@@ -1,155 +0,0 @@
-"""`get_positions()` consumes the POSITIONS subscription's push channel.
-
-XTB's xStation5 CoreAPI doesn't echo a `reqId`-correlated response for
-`getPositions`; position data arrives via `status=1` push events with
-`eid=POSITIONS`. These tests verify the push-collecting implementation.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from xtb_api.types.enums import SocketStatus
-from xtb_api.types.websocket import WSClientConfig
-from xtb_api.ws.parsers import parse_position_trade
-from xtb_api.ws.ws_client import XTBWebSocketClient
-
-
-def _mock_ws_send() -> AsyncMock:
-    return AsyncMock(return_value=None)
-
-
-def _trade(position_id: str, symbol: str = "CIG.PL", side: int = 0) -> dict:
-    return {
-        "positionId": position_id,
-        "symbol": symbol,
-        "side": side,
-        "volume": 10,
-        "openPrice": 23.17,
-        "sl": 22.0,
-        "tp": 25.0,
-        "swap": 0.0,
-        "commission": 0.1,
-        "margin": 50.0,
-        "openTime": 1700000000,
-        "idQuote": 123,
-    }
-
-
-def _make_client() -> XTBWebSocketClient:
-    config = WSClientConfig(
-        url="wss://api5demoa.x-station.eu/v1/xstation",
-        account_number=12345678,
-    )
-    client = XTBWebSocketClient(config)
-    # Bypass real connect: set status to CONNECTED (what is_connected reads)
-    # and stub the underlying socket.
-    client._status = SocketStatus.CONNECTED
-    client._ws = MagicMock()
-    client._ws.send = _mock_ws_send()
-    return client
-
-
-# ── parse_position_trade (extracted helper) ────────────────────────
-
-
-def test_parse_position_trade_extracts_expected_fields() -> None:
-    pos = parse_position_trade(_trade("P1"))
-    assert pos.symbol == "CIG.PL"
-    assert pos.order_id == "P1"
-    assert pos.volume == 10
-    assert pos.open_price == 23.17
-    assert pos.side == "buy"
-    assert pos.stop_loss == 22.0
-    assert pos.take_profit == 25.0
-
-
-def test_parse_position_trade_side_sell() -> None:
-    pos = parse_position_trade(_trade("P1", side=1))
-    assert pos.side == "sell"
-
-
-def test_parse_position_trade_zero_sl_tp_become_none() -> None:
-    trade = _trade("P1")
-    trade["sl"] = 0
-    trade["tp"] = 0
-    pos = parse_position_trade(trade)
-    assert pos.stop_loss is None
-    assert pos.take_profit is None
-
-
-# ── get_positions push-collection ──────────────────────────────────
-
-
-@pytest.mark.asyncio
-async def test_get_positions_collects_first_burst(monkeypatch: pytest.MonkeyPatch) -> None:
-    client = _make_client()
-
-    async def fire_pushes_after_subscribe() -> None:
-        # Give the coroutine a moment to register its 'position' listener.
-        await asyncio.sleep(0.05)
-        client._emit("position", _trade("P1", "CIG.PL"))
-        client._emit("position", _trade("P2", "AAPL.US"))
-
-    # Run the push firing concurrently with get_positions.
-    pushes_task = asyncio.create_task(fire_pushes_after_subscribe())
-    positions = await client.get_positions(max_wait_ms=2000, quiet_ms=300)
-    await pushes_task
-
-    assert len(positions) == 2
-    assert {p.order_id for p in positions} == {"P1", "P2"}
-    client._ws.send.assert_awaited()  # subscription was fired
-
-
-@pytest.mark.asyncio
-async def test_get_positions_dedups_by_position_id() -> None:
-    client = _make_client()
-
-    async def fire_duplicates() -> None:
-        await asyncio.sleep(0.05)
-        client._emit("position", _trade("P1", "CIG.PL"))
-        client._emit("position", _trade("P1", "CIG.PL"))  # duplicate update
-        client._emit("position", _trade("P2", "LPP.PL"))
-
-    task = asyncio.create_task(fire_duplicates())
-    positions = await client.get_positions(max_wait_ms=2000, quiet_ms=300)
-    await task
-
-    assert len(positions) == 2
-    assert {p.order_id for p in positions} == {"P1", "P2"}
-
-
-@pytest.mark.asyncio
-async def test_get_positions_returns_empty_on_no_pushes() -> None:
-    client = _make_client()
-    # No pushes fired — must return quickly after max_wait.
-    positions = await client.get_positions(max_wait_ms=300, quiet_ms=50)
-    assert positions == []
-
-
-@pytest.mark.asyncio
-async def test_get_positions_removes_listener_on_exit() -> None:
-    client = _make_client()
-    # Record initial listener count on the 'position' event (may be non-zero
-    # from other hooks registered in the live client).
-    before = len(client._event_handlers.get("position", []))
-    await client.get_positions(max_wait_ms=200, quiet_ms=50)
-    after = len(client._event_handlers.get("position", []))
-    assert before == after, "Handler leaked after get_positions exits"
-
-
-@pytest.mark.asyncio
-async def test_get_positions_raises_when_not_connected() -> None:
-    config = WSClientConfig(
-        url="wss://api5demoa.x-station.eu/v1/xstation",
-        account_number=12345678,
-    )
-    client = XTBWebSocketClient(config)
-    # Default state: not connected.
-    from xtb_api.exceptions import XTBConnectionError
-
-    with pytest.raises(XTBConnectionError):
-        await client.get_positions(max_wait_ms=100)