architect-py 3.2.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

examples/funding_rate_mean_reversion_algo.py

@@ -0,0 +1,186 @@
+"""
+Do *NOT* run this script in production. This script is for educational purposes only.
+"""
+
+import asyncio
+from decimal import Decimal
+from typing import AsyncIterator, Optional
+
+from architect_py.async_client import AsyncClient
+from architect_py.common_types.order_dir import OrderDir
+from architect_py.common_types.tradable_product import TradableProduct
+from architect_py.graphql_client.exceptions import GraphQLClientHttpError
+from architect_py.grpc.models.definitions import OrderType, TimeInForceEnum
+from architect_py.grpc.models.Orderflow.Orderflow import (
+    TaggedOrderAck,
+    TaggedOrderOut,
+    TaggedOrderReject,
+)
+from architect_py.grpc.models.Orderflow.OrderflowRequest import (
+    OrderflowRequest,
+    PlaceOrder,
+)
+
+from .common import connect_async_client
+
+venue = "BINANCE"
+product = "BTC-USDT Perpetual"
+tradable_product = TradableProduct(product, "USDT Crypto")
+best_bid_price: Optional[Decimal] = None
+best_ask_price: Optional[Decimal] = None
+current_funding_rate: Optional[Decimal] = None  # as fraction, e.g. 0.0001 = 1 bp
+target_position = 0
+current_position = 0
+
+
+class OrderflowRequester:
+    def __init__(self):
+        self.queue: asyncio.Queue[OrderflowRequest] = asyncio.Queue()
+
+    async def __aiter__(self) -> AsyncIterator[OrderflowRequest]:
+        while True:
+            value = await self.queue.get()  # Wait for a value
+            yield value  # Yield it when available
+
+    async def __anext__(self) -> OrderflowRequest:
+        return await self.queue.get()
+
+    async def put(self, value: OrderflowRequest) -> None:
+        # OrderflowRequest contains: PlaceOrder, CancelOrder, CancelAllOrders
+        await self.queue.put(value)  # Put value into the queue
+
+
+async def update_marketdata(c: AsyncClient):
+    while True:
+        ticker = await c.get_ticker(tradable_product, venue)
+        if ticker.funding_rate:
+            global current_funding_rate
+            global target_position
+            current_funding_rate = ticker.funding_rate
+            # set target_position based on funding rate
+            if current_funding_rate >= 0.1:
+                target_position = -10
+            elif current_funding_rate >= 0.05:
+                target_position = -5
+            elif current_funding_rate >= 0.0001:
+                target_position = 1
+            elif current_funding_rate >= -0.05:
+                target_position = 5
+            else:
+                target_position = 10
+        if ticker.bid_price:
+            global best_bid_price
+            best_bid_price = ticker.bid_price
+        if ticker.ask_price:
+            global best_ask_price
+            best_ask_price = ticker.ask_price
+        await asyncio.sleep(1)
+
+
+async def subscribe_and_print_orderflow(
+    c: AsyncClient, orderflow_requester: OrderflowRequester
+):
+    try:
+        stream = c.orderflow(orderflow_requester)
+        """
+        subscribe_orderflow_stream is a duplex_stream meaning that it is a stream that can be read from and written to.
+        This is a stream that will be used to send orders to the Architect and receive order updates from the Architect.
+        """
+        async for orderflow in stream:
+            if isinstance(orderflow, TaggedOrderAck):
+                print(f"<!> ACK {orderflow.order_id}")
+            if isinstance(orderflow, TaggedOrderReject):
+                print(f"<!> REJECT {orderflow.id} {orderflow.r}: {orderflow.rm}")
+                # reject reason, reject message
+            elif isinstance(orderflow, TaggedOrderOut):
+                print(f"<!> OUT {orderflow.id}")
+    except GraphQLClientHttpError as e:
+        print(e.status_code)
+        print(e.response.json())
+
+
+async def step_to_target_position(
+    c: AsyncClient, orderflow_requester: OrderflowRequester
+):
+    while True:
+        await asyncio.sleep(10)
+        # check open orders
+        open_orders = await c.get_open_orders()
+        n = len(open_orders)
+        if n > 0:
+            print("there are {n} open orders, skipping step")
+            continue
+
+        order = None
+        # send orders to step to target position
+        if current_position < target_position:
+            if best_ask_price is not None:
+                # buy 1 contract
+
+                # make sure to import the correct PlaceOrder from architect_py.grpc_client.Orderflow.OrderflowRequest
+                order = PlaceOrder.new(
+                    symbol=tradable_product,
+                    dir=OrderDir.BUY,
+                    quantity=Decimal(1),
+                    execution_venue=None,
+                    limit_price=best_ask_price,
+                    time_in_force=TimeInForceEnum.DAY,
+                    order_type=OrderType.LIMIT,
+                )
+
+        elif current_position > target_position:
+            if best_bid_price is not None:
+                # sell 1 contract
+
+                # make sure to import the correct PlaceOrder from architect_py.grpc_client.Orderflow.OrderflowRequest
+                order = PlaceOrder.new(
+                    symbol=tradable_product,
+                    dir=OrderDir.SELL,
+                    quantity=Decimal(1),
+                    execution_venue=None,
+                    limit_price=best_bid_price,
+                    time_in_force=TimeInForceEnum.DAY,
+                    order_type=OrderType.LIMIT,
+                )
+
+        if order is not None:
+            await orderflow_requester.put(
+                order
+            )  # this will add the order to the queue to send over
+
+
+async def print_info(c: AsyncClient):
+    accounts = await c.list_accounts()
+    while True:
+        await asyncio.sleep(3)
+        account_summaries = await c.get_account_summaries(
+            accounts=[account.account.name for account in accounts]
+        )
+        pos = Decimal(0)
+        for account in account_summaries:
+            for name, balance in account.balances.items():
+                print(f"balance for {name}: {balance}")
+                pos += balance
+        global current_position
+        current_position = pos
+        print("---")
+        print(f"info : funding_rate: {current_funding_rate}")
+        print(f"info : bbo: {best_bid_price} {best_ask_price}")
+        print(f"info : current_position: {current_position}")
+        print(f"info : target_position: {target_position}")
+
+
+async def main():
+    c = await connect_async_client()
+
+    orderflow_requester = OrderflowRequester()
+
+    await asyncio.gather(
+        update_marketdata(c),
+        step_to_target_position(c, orderflow_requester),
+        print_info(c),
+        subscribe_and_print_orderflow(c, orderflow_requester),
+    )
+
+
+asyncio.run(main())

examples/order_sending.py

@@ -0,0 +1,91 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta, timezone
+from decimal import Decimal
+
+from architect_py.async_client import AsyncClient
+from architect_py.common_types.order_dir import OrderDir
+from architect_py.common_types.tradable_product import TradableProduct
+from architect_py.grpc.models.definitions import GoodTilDate, OrderType, TimeInForceEnum
+from examples.common import connect_async_client
+
+LOGGER = logging.getLogger(__name__)
+
+
+async def search_symbol(c: AsyncClient) -> tuple[str, TradableProduct]:
+    venue = "CME"
+    markets = await c.search_symbols(
+        search_string="ES",
+        execution_venue=venue,
+    )
+    market = markets[0]
+    return venue, market
+
+
+async def test_send_order(client: AsyncClient, account: str):
+    venue, symbol = await search_symbol(client)
+
+    snapshot = await client.get_market_snapshot(symbol=symbol, venue=venue)
+    if snapshot is None:
+        return ValueError(f"Market snapshot for {symbol} is None")
+
+    if snapshot.best_ask is None or snapshot.best_bid is None:
+        return ValueError(f"Market snapshot for {symbol} is None")
+
+    best_bid_price, best_bid_quantity = snapshot.best_bid
+
+    d = datetime.now(tz=timezone.utc) + timedelta(days=1)
+    gtd = GoodTilDate(d)
+
+    order = await client.place_limit_order(
+        symbol=symbol,
+        odir=OrderDir.BUY,
+        quantity=best_bid_quantity,
+        order_type=OrderType.LIMIT,
+        execution_venue="CME",
+        post_only=True,
+        limit_price=best_bid_price
+        - (snapshot.best_ask[0] - best_bid_price) * Decimal(10),
+        account=account,
+        time_in_force=gtd,
+    )
+    logging.critical(f"ORDER TEST: {order}")
+
+    assert order is not None
+
+    cancel = await client.cancel_order(order.id)
+
+    return cancel
+
+
+async def test_cancel_all_orders(client: AsyncClient):
+    await client.cancel_all_orders()
+
+
+async def test_send_market_pro_order(client: AsyncClient, account: str):
+    venue, symbol = await search_symbol(client)
+    print(symbol)
+
+    await client.send_market_pro_order(
+        symbol=symbol,
+        execution_venue=venue,
+        odir=OrderDir.BUY,
+        quantity=Decimal(1),
+        account=account,
+        time_in_force=TimeInForceEnum.IOC,
+    )
+
+
+async def main():
+    client: AsyncClient = await connect_async_client()
+    accounts = await client.list_accounts()
+    account: str = accounts[0].account.name
+
+    await test_send_order(client, account)
+    await test_send_market_pro_order(client, account)
+
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(main())

examples/stream_l1_marketdata.py

@@ -0,0 +1,25 @@
+import asyncio
+
+from architect_py.async_client import AsyncClient
+from architect_py.common_types.tradable_product import TradableProduct
+
+from .common import connect_async_client
+
+
+async def main():
+    c: AsyncClient = await connect_async_client()
+
+    async for snap in c.stream_l1_book_snapshots(
+        symbols=[TradableProduct("ES 20250620 CME Future/USD")],
+        venue="CME",
+    ):
+        best_bid_s = "<no bid>"
+        best_ask_s = "<no ask>"
+        if snap.best_bid:
+            best_bid_s = f"{snap.best_bid[1]} x {snap.best_bid[0]}"  # size x price
+        if snap.best_ask:
+            best_ask_s = f"{snap.best_ask[0]} x {snap.best_ask[1]}"  # price x size
+        print(f"{snap.symbol} {snap.timestamp} {best_bid_s} {best_ask_s}")
+
+
+asyncio.run(main())

examples/stream_l2_marketdata.py

@@ -0,0 +1,38 @@
+import asyncio
+
+from architect_py.async_client import AsyncClient
+from architect_py.common_types.tradable_product import TradableProduct
+
+from .common import connect_async_client
+
+buy_columns = "{:>15} {:>15}"
+sell_columns = "{:<15} {:<15}"
+green = "\033[32m"
+red = "\033[31m"
+normal = "\033[0m"
+
+
+async def print_l2_book(c: AsyncClient, symbol: TradableProduct, venue: str):
+    book = await c.subscribe_l2_book(symbol, venue)
+    while True:
+        print(f"book timestamp: {book.timestamp}")
+        print((buy_columns + " " + sell_columns).format("Size", "Bid", "Ask", "Size"))
+        for i in range(min(20, len(book.bids), len(book.asks))):
+            b = book.bids[i]
+            s = book.asks[i]
+            print(
+                (green + buy_columns).format(b[1], b[0]),
+                (red + sell_columns).format(s[0], s[1]),
+            )
+        print(normal)
+        await asyncio.sleep(1)
+
+
+async def main():
+    c: AsyncClient = await connect_async_client()
+    market_symbol = TradableProduct("ES 20250620 CME Future/USD")
+    venue = "CME"
+    await print_l2_book(c, market_symbol, venue=venue)
+
+
+asyncio.run(main())

examples/trades.py

@@ -0,0 +1,21 @@
+import asyncio
+
+from architect_py.async_client import AsyncClient
+from architect_py.common_types.tradable_product import TradableProduct
+from architect_py.graphql_client.exceptions import GraphQLClientHttpError
+
+from .common import connect_async_client
+
+
+async def main():
+    c: AsyncClient = await connect_async_client()
+    market_id = TradableProduct("BTC Crypto", "USD")
+    try:
+        async for trade in c.stream_trades(market_id, venue="COINBASE"):
+            print(trade)
+    except GraphQLClientHttpError as e:
+        print(e.status_code)
+        print(e.response.json())
+
+
+asyncio.run(main())

examples/tutorial_async.py

@@ -0,0 +1,86 @@
+import asyncio
+from decimal import Decimal
+
+from architect_py.async_client import OrderDir
+from architect_py.common_types.tradable_product import TradableProduct
+from architect_py.graphql_client.enums import OrderStatus
+from examples.common import connect_async_client
+
+
+async def main():
+    c = await connect_async_client()
+
+    market = TradableProduct("ES 20281215 CME Future/US")
+    execution_venue = "CME"
+
+    # Get market snapshot for a single market
+    # Market snapshots tell you the current best bid, best ask,
+    # and other ticker info for the given symbol.
+    print()
+    print(f"Market snapshot for {market}")
+    market_snapshot = await c.get_market_snapshot(symbol=market, venue=execution_venue)
+    print(f"Best bid: {market_snapshot.best_bid}")
+    print(f"Best ask: {market_snapshot.best_ask}")
+
+    # List your FCM accounts
+    print()
+    print("Your FCM accounts:")
+    accounts = await c.list_accounts()
+    for account in accounts:
+        print(f"{account.account.name}")
+
+    account_id = accounts[0].account.id
+
+    # Place a limit order $100 below the best bid
+    if (best_bid := market_snapshot.best_bid) is not None:
+        bid_px = best_bid[0]
+    else:
+        raise ValueError("No bid price available")
+
+    limit_price = bid_px - Decimal(100)
+    quantity = Decimal(1)
+    account = accounts[0]
+    order = None
+    print()
+    if (
+        input(
+            f"Place a limit order to BUY 1 LIMIT {limit_price} on account {account.account.name}? [y/N]"
+        )
+        == "y"
+    ):
+        order = await c.place_limit_order(
+            symbol=market,
+            execution_venue=execution_venue,
+            odir=OrderDir.BUY,
+            quantity=quantity,
+            limit_price=limit_price,
+            account=str(account_id),
+        )
+    else:
+        raise ValueError("Order was not placed")
+    print(f"Order placed with ID: {order.id}")
+
+    # Poll order status until rejected or fully executed
+    # After 5 seconds, cancel the order
+    i = 0
+    while order.status is OrderStatus.OPEN:
+        await asyncio.sleep(1)
+        print(f"...order state: {order.status}")
+        order = await c.get_order(order.id)
+        assert order is not None
+        i += 1
+        if i == 5:
+            print("Canceling order")
+            await c.cancel_order(order.id)
+
+    if order.status is OrderStatus.REJECTED:
+        print(f"Order was rejected: {order.reject_reason}")
+    elif order.status is OrderStatus.CANCELED:
+        print("Order was canceled")
+    elif order.status is OrderStatus.OUT:
+        print(f"Order was filled for qty: {order.filled_quantity}")
+        print(f"Average execution price: {order.average_fill_price}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/tutorial_sync.py

@@ -0,0 +1,95 @@
+import pprint
+import time
+from decimal import Decimal
+
+from architect_py.common_types.order_dir import OrderDir
+from architect_py.graphql_client.enums import OrderStatus
+from architect_py.utils.nearest_tick import TickRoundMethod
+
+from .common import confirm, connect_client, print_book, print_open_orders
+
+c = connect_client()
+
+venue = "CME"
+
+# find ES markets
+symbols = c.search_symbols(execution_venue=venue, search_string="ES")
+print("\nFound markets:")
+
+for s in symbols:
+    print(f"  • {s}")
+
+symbol = symbols[0]
+
+# Lookup information about a single market
+print(f"\nDetails for {symbols[0]}:")
+product_info = c.get_product_info(symbol)
+assert product_info is not None
+pprint.pp(product_info)
+
+# Get market snapshot for a single market
+# Market snapshots tell you the current best bid, best ask,
+# and other ticker info for the given symbol.
+# this function is an alias for get_l1_book_snapshot
+print(f"\nMarket snapshot for {product_info.symbol}:")
+market_snapshot = c.get_market_snapshot(symbol=symbol, venue=venue)
+
+pprint.pp(market_snapshot)
+
+# Get L2 snapshot for a single market
+print(f"\nL2 snapshot for {product_info.symbol}:")
+start = time.perf_counter()
+book = c.get_l2_book_snapshot(symbol=symbol, venue=venue)
+elapsed = time.perf_counter() - start
+print(f"Got book snapshot in {elapsed:.4f} seconds\n")
+print_book(book)
+
+# Get your accounts
+print("\nYour accounts:")
+accounts = c.list_accounts()
+for account in accounts:
+    print(f"  • {account.account.name}")
+
+# Check your open orders
+print("\nCurrent open orders:")
+orders = c.get_open_orders()
+print_open_orders(orders)
+
+# Place a limit order 20% below the best bid
+best_bid = market_snapshot.best_bid
+assert best_bid is not None
+best_bid_price, best_bid_quantity = best_bid
+limit_price = best_bid_price * Decimal(0.8)
+account = accounts[0]
+order = None
+
+if confirm(
+    f"Place a limit order to BUY 1 {symbol} LIMIT {limit_price} on account {account.account.name}?"
+):
+    order = c.send_limit_order(
+        symbol=symbol,
+        execution_venue=venue,
+        odir=OrderDir.BUY,
+        quantity=best_bid_quantity,
+        limit_price=limit_price,
+        account=account.account.name,
+        price_round_method=TickRoundMethod.ROUND,
+    )
+assert order is not None
+print(f"\nOrder placed with ID: {order.id}")
+
+# Poll order status until rejected or fully executed
+while order.status is OrderStatus.OPEN:
+    time.sleep(1)
+    print(f"...order state: {order.status}")
+    order = c.get_order(order.id)
+    assert order is not None
+
+# Print final order state
+if order.status is OrderStatus.REJECTED:
+    print(f"Order was rejected: {order.reject_reason}")
+elif order.status is OrderStatus.CANCELED:
+    print("Order was canceled")
+elif order.status is OrderStatus.OUT:
+    print(f"Order was filled for qty: {order.filled_quantity}")
+    print(f"Average execution price: {order.average_fill_price}")