Get Trade Intent by External ID

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "intent_id": "trade_001",
  "symbol": "AAPL",
  "side": "buy",
  "quantity": 10,
  "order_type": "market",
  "status": "filled",
  "broker_id": "alpaca_abc123",
  "orders": [
    {
      "id": "660e8400-e29b-41d4-a716-446655440000",
      "broker_order_id": "order_123",
      "status": "filled",
      "fills": [
        {
          "quantity": 10,
          "price": 175.50,
          "filled_at": "2025-11-30T10:30:00Z"
        }
      ],
      "created_at": "2025-11-30T10:29:59Z",
      "updated_at": "2025-11-30T10:30:00Z"
    }
  ],
  "created_at": "2025-11-30T10:29:59Z",
  "updated_at": "2025-11-30T10:30:00Z"
}

{
  "detail": "Trade Intent not found",
  "error_code": "not_found",
  "request_id": "req_abc123"
}

import asyncio
from sniperoute import SnipeRouteClient
from sniperoute.models import TradeIntentRequest, OrderSide, OrderType
from decimal import Decimal
 
async def create_and_check():
    client = SnipeRouteClient()
 
    # Create intent
    intent = TradeIntentRequest(
        intent_id="trade_001",
        symbol="AAPL",
        side=OrderSide.BUY,
        quantity=Decimal("10"),
        order_type=OrderType.MARKET,
        broker_id="alpaca_abc123"
    )
 
    response = await client.create_intent(intent)
    print(f"Created: {response.intent_id}")
 
    # Check status using same intent_id
    status = await client.get_intent_by_external_id("trade_001")
    print(f"Status: {status.status}")
 
asyncio.run(create_and_check())

import asyncio
 
async def wait_for_fill(client, intent_id, timeout=60):
    """Poll until order fills or times out."""
    start_time = asyncio.get_event_loop().time()
 
    while True:
        intent = await client.get_intent_by_external_id(intent_id)
 
        if intent.status == "filled":
            print("Order filled!")
            return intent
 
        elif intent.status == "rejected":
            print("Order rejected")
            return intent
 
        elif asyncio.get_event_loop().time() - start_time > timeout:
            raise TimeoutError("Order did not fill within timeout")
 
        await asyncio.sleep(1)  # Poll every second
 
# Usage
filled_intent = await wait_for_fill(client, "trade_001")

async def track_intents(client, intent_ids):
    """Check status of multiple intents."""
    results = {}
 
    for intent_id in intent_ids:
        try:
            intent = await client.get_intent_by_external_id(intent_id)
            results[intent_id] = intent.status
        except Exception as e:
            results[intent_id] = f"Error: {e}"
 
    return results
 
# Usage
status_map = await track_intents(
    client,
    ["trade_001", "trade_002", "trade_003"]
)
 
for intent_id, status in status_map.items():
    print(f"{intent_id}: {status}")

async def get_fill_details(client, intent_id):
    """Get detailed fill information."""
    intent = await client.get_intent_by_external_id(intent_id)
 
    if intent.status != "filled":
        print(f"Order not filled yet. Status: {intent.status}")
        return
 
    total_quantity = 0
    total_value = 0.0
 
    for order in intent.orders:
        for fill in order.fills:
            total_quantity += fill.quantity
            total_value += fill.quantity * fill.price
 
            print(f"Fill: {fill.quantity} @ ${fill.price} at {fill.filled_at}")
 
    avg_price = total_value / total_quantity if total_quantity > 0 else 0
    print(f"\nTotal: {total_quantity} shares at avg price ${avg_price:.2f}")
 
# Usage
await get_fill_details(client, "trade_001")