xtb-api-python 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

xtb_api/ws/parsers.py

@@ -49,36 +49,41 @@ def parse_balance(
     )
 
 
+def parse_position_trade(trade: dict[str, Any]) -> Position:
+    """Convert a single `xcfdtrade` dict (as pushed on the POSITIONS
+    subscription) into a `Position`.
+
+    Callers that receive the wrapped `{value: {xcfdtrade: ...}}` shape
+    should use `parse_positions()` instead.
+    """
+    side_val = int(trade.get("side", 0))
+    return Position(
+        symbol=str(trade.get("symbol", "")),
+        instrument_id=int(trade["idQuote"]) if trade.get("idQuote") is not None else None,
+        volume=float(trade.get("volume", 0)),
+        current_price=0.0,
+        open_price=float(trade.get("openPrice", 0)),
+        stop_loss=float(trade["sl"]) if trade.get("sl") and trade["sl"] != 0 else None,
+        take_profit=float(trade["tp"]) if trade.get("tp") and trade["tp"] != 0 else None,
+        profit_percent=0.0,
+        profit_net=0.0,
+        swap=float(trade["swap"]) if trade.get("swap") is not None else None,
+        side="buy" if side_val == Xs6Side.BUY else "sell",
+        order_id=str(trade["positionId"]) if trade.get("positionId") is not None else None,
+        commission=float(trade["commission"]) if trade.get("commission") is not None else None,
+        margin=float(trade["margin"]) if trade.get("margin") is not None else None,
+        open_time=int(trade["openTime"]) if trade.get("openTime") is not None else None,
+    )
+
+
 def parse_positions(elements: list[dict[str, Any]]) -> list[Position]:
     """Parse open trading positions from subscription elements."""
     positions: list[Position] = []
-
     for el in elements:
         trade = (el or {}).get("value", {}).get("xcfdtrade")
         if not trade:
             continue
-
-        side_val = int(trade.get("side", 0))
-        positions.append(
-            Position(
-                symbol=str(trade.get("symbol", "")),
-                instrument_id=int(trade["idQuote"]) if trade.get("idQuote") is not None else None,
-                volume=float(trade.get("volume", 0)),
-                current_price=0.0,
-                open_price=float(trade.get("openPrice", 0)),
-                stop_loss=float(trade["sl"]) if trade.get("sl") and trade["sl"] != 0 else None,
-                take_profit=float(trade["tp"]) if trade.get("tp") and trade["tp"] != 0 else None,
-                profit_percent=0.0,
-                profit_net=0.0,
-                swap=float(trade["swap"]) if trade.get("swap") is not None else None,
-                side="buy" if side_val == Xs6Side.BUY else "sell",
-                order_id=str(trade["positionId"]) if trade.get("positionId") is not None else None,
-                commission=float(trade["commission"]) if trade.get("commission") is not None else None,
-                margin=float(trade["margin"]) if trade.get("margin") is not None else None,
-                open_time=int(trade["openTime"]) if trade.get("openTime") is not None else None,
-            )
-        )
-
+        positions.append(parse_position_trade(trade))
     return positions
 
 

xtb_api/ws/ws_client.py

@@ -52,7 +52,7 @@ from xtb_api.ws.parsers import (
     parse_balance,
     parse_instruments,
     parse_orders,
-    parse_positions,
+    parse_position_trade,
     parse_quote,
 )
 
@@ -533,15 +533,81 @@ class XTBWebSocketClient:
 
         return parse_balance(self._extract_elements(res), account.currency, account.accountNo)
 
-    async def get_positions(self) -> list[Position]:
-        """Get all open trading positions."""
-        res = await self.send(
-            "getPositions",
-            {"getAndSubscribeElement": {"eid": SubscriptionEid.POSITIONS}},
-            timeout_ms=30000,
-        )
+    async def get_positions(
+        self,
+        *,
+        max_wait_ms: int = 5000,
+        quiet_ms: int = 500,
+    ) -> 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.
+        """
+        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))
 
-        return parse_positions(self._extract_elements(res))
+            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())
 
     async def get_orders(self) -> list[PendingOrder]:
         """Get all pending (limit/stop) orders."""

{xtb_api_python-0.5.2.dist-info → xtb_api_python-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtb-api-python
-Version: 0.5.2
+Version: 0.5.3
 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
@@ -52,7 +52,9 @@ Python client for the XTB xStation5 trading platform. Dead-simple API that handl
 - **2FA Support** — Automatic TOTP handling when `totp_secret` is provided
 - **Real-time Data** — Live quotes, positions, balance via WebSocket push events
 - **Trading** — Buy/sell market orders with SL/TP via gRPC-web
-- **11,888+ Instruments** — Full symbol search with caching
+- **Volume-Validated Orders** — `buy`/`sell` reject `volume < 1` before touching the wire
+- **Persistent Instrument Cache** — `InstrumentRegistry` caches symbol → instrument-ID lookups to disk
+- **Full Symbol Search** — Search and resolve all listed instruments with caching
 - **Modern Python** — async/await, Pydantic models, strict typing, Python 3.12+
 
 ## Requirements
@@ -129,6 +131,12 @@ async def main():
     # Search instruments
     results = await client.search_instrument("Apple")
 
+    # Persistent instrument cache (avoids re-fetching the full symbol list)
+    from xtb_api import InstrumentRegistry
+    registry = InstrumentRegistry("~/.xtb_instruments.json")
+    matched = await registry.populate(client, ["AAPL.US", "EURUSD"])
+    instrument_id = registry.get("AAPL.US")  # int | None
+
     # Trading (USE WITH CAUTION!)
     result = await client.buy("AAPL.US", volume=1, stop_loss=150.0, take_profit=200.0)
     print(f"Order: {result.order_id}")
@@ -162,6 +170,8 @@ await client.sell("CIG.PL", volume=100, options=TradeOptions(
 ))
 ```
 
+> `TradeResult.price` is populated by polling open positions immediately after fill. If the position cannot be located within the poll window, `price` remains `None`.
+
 ## API Reference
 
 ### `XTBClient`
@@ -194,6 +204,18 @@ await client.sell("CIG.PL", volume=100, options=TradeOptions(
 | `account_server` | No | `"XS-real1"` | gRPC account server |
 | `auto_reconnect` | No | `True` | Auto-reconnect on disconnect |
 
+### `InstrumentRegistry`
+
+Persistent symbol → instrument-ID cache, stored as JSON.
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `InstrumentRegistry(path)` | — | Load (or create) the JSON cache at `path` |
+| `get(symbol)` | `int \| None` | Cached instrument ID for `symbol`, or `None` |
+| `set(symbol, id)` | `None` | Cache one mapping and persist immediately |
+| `populate(client, symbols)` | `dict[str, int]` | Download the full symbol list via `client`, match requested `symbols` (case-insensitive, dot-less fallback), persist, return new matches |
+| `ids` | `dict[str, int]` | Read-only copy of the full cache |
+
 ### WebSocket URLs
 
 | Environment | URL |
@@ -212,8 +234,9 @@ ws = client.ws
 # gRPC client (available after first trade)
 grpc = client.grpc_client
 
-# Auth manager
+# Auth manager (accessor, or import the public alias)
 auth = client.auth
+from xtb_api import XTBAuth  # public alias for the AuthManager class
 tgt = await auth.get_tgt()
 ```
 

{xtb_api_python-0.5.2.dist-info → xtb_api_python-0.5.3.dist-info}/RECORD

@@ -19,10 +19,10 @@ xtb_api/types/instrument.py,sha256=uxGB3LrE1IgP3UeEMu9c50Mvqmplr3DmgUbLwjg4i14,9
 xtb_api/types/trading.py,sha256=fGLGga-kMX7vDvE848H7lUnw-kHpTcqq6a8P25RDu2k,3033
 xtb_api/types/websocket.py,sha256=66vZSC6hdlglO5EEqPSciBbtBVunGV0L-0pLiZwVrQo,3705
 xtb_api/ws/__init__.py,sha256=6QNzj6rXiGWa9vU-o_IvVTqU7nDqPaYDJnTQhX-1pXY,106
-xtb_api/ws/parsers.py,sha256=ApEjm3uX-QhiyaM8U1RpZByVbU0ijL5jnm4FFIApyNk,6222
-xtb_api/ws/ws_client.py,sha256=X_bBaAw80aHEECRol33aDJqMfVu5onqrQ8a7ANrrZ8s,34077
-xtb_api_python-0.5.2.dist-info/METADATA,sha256=QNHFjD2C2vtf_aqSVn6pT9ikkPhBcfEK9K0pN6Coxpc,8464
-xtb_api_python-0.5.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-xtb_api_python-0.5.2.dist-info/entry_points.txt,sha256=HhB6G6gQU-c43Y0YowXSqXXOTCd1CK8fvy5guFdzy0s,50
-xtb_api_python-0.5.2.dist-info/licenses/LICENSE,sha256=fEnrQRlNl8P7GRU9YAaLjbNRfQ0qe0At5LRkCmM4j0I,1073
-xtb_api_python-0.5.2.dist-info/RECORD,,
+xtb_api/ws/parsers.py,sha256=ipTkURuz-WF8ZgYOgWDSNBbUp1eYaNQScrQN6rUufDI,6397
+xtb_api/ws/ws_client.py,sha256=qpZ3tiEgf2BIEvouK1xdGhrAvFw6_AwYzbREP5bHtlY,36768
+xtb_api_python-0.5.3.dist-info/METADATA,sha256=PpVsMp3Z6JgKPMyRd4XBANA-ivBWIAYn79uzEqkIP0E,9918
+xtb_api_python-0.5.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+xtb_api_python-0.5.3.dist-info/entry_points.txt,sha256=HhB6G6gQU-c43Y0YowXSqXXOTCd1CK8fvy5guFdzy0s,50
+xtb_api_python-0.5.3.dist-info/licenses/LICENSE,sha256=fEnrQRlNl8P7GRU9YAaLjbNRfQ0qe0At5LRkCmM4j0I,1073
+xtb_api_python-0.5.3.dist-info/RECORD,,