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

examples/order_sending.py

@@ -0,0 +1,92 @@
+import asyncio
+import logging
+from decimal import Decimal
+
+from architect_py.async_client import AsyncClient
+from architect_py.graphql_client.enums import OrderType, TimeInForce
+from architect_py.scalars import OrderDir, TradableProduct
+
+LOGGER = logging.getLogger(__name__)
+
+api_key = None
+api_secret = None
+HOST = None
+ACCOUNT = None
+
+
+if api_key is None or api_secret is None or HOST is None or ACCOUNT is None:
+    raise ValueError(
+        "Please set the api_key, api_secret, HOST, and ACCOUNT variables before running this script"
+    )
+
+
+client = AsyncClient(host=HOST, api_key=api_key, api_secret=api_secret)
+
+
+async def search_symbol() -> tuple[str, TradableProduct]:
+    venue = "CME"
+    markets = await client.search_symbols(
+        search_string="ES",
+        execution_venue=venue,
+    )
+    market = markets[0]
+    return venue, market
+
+
+async def test_send_order():
+    venue, symbol = await search_symbol()
+
+    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.ask_price is None or snapshot.bid_price is None:
+        return ValueError(f"Market snapshot for {symbol} is None")
+
+    order = await client.send_limit_order(
+        symbol=symbol,
+        odir=OrderDir.BUY,
+        quantity=Decimal(1),
+        order_type=OrderType.LIMIT,
+        execution_venue="CME",
+        post_only=True,
+        limit_price=snapshot.bid_price
+        - (snapshot.ask_price - snapshot.bid_price) * Decimal(10),
+        account=ACCOUNT,
+        time_in_force=TimeInForce.IOC,
+    )
+    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():
+    await client.cancel_all_orders()
+
+
+async def test_send_market_pro_order():
+    venue, symbol = await search_symbol()
+    print(symbol)
+
+    await client.send_market_pro_order(
+        symbol=symbol,
+        execution_venue=venue,
+        odir=OrderDir.BUY,
+        quantity=Decimal(1),
+        account=ACCOUNT,
+        time_in_force=TimeInForce.IOC,
+    )
+
+
+async def main():
+    await test_send_market_pro_order()
+
+
+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.scalars import TradableProduct
+
+from .common import connect_async_client
+
+
+async def main():
+    c: AsyncClient = await connect_async_client()
+
+    async for snap in c.subscribe_l1_book_stream(
+        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,40 @@
+import asyncio
+
+from architect_py.async_client import AsyncClient
+from architect_py.scalars 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()
+    endpoint = "app.architect.co"  # one example of alternative can be "binance.marketdata.architect.co"
+    await c.grpc_client.change_channel(endpoint)
+    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.graphql_client.exceptions import GraphQLClientHttpError
+from architect_py.scalars import TradableProduct
+
+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.subscribe_trades_stream(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,84 @@
+import asyncio
+from decimal import Decimal
+
+from architect_py.async_client import OrderDir
+from architect_py.graphql_client.enums import OrderStatus
+from architect_py.scalars import TradableProduct
+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.bid_price}")
+    print(f"Best ask: {market_snapshot.ask_price}")
+
+    # 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
+    best_bid = market_snapshot.bid_price
+    if best_bid is None:
+        raise ValueError("No bid price available")
+    limit_price = best_bid - 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.send_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.graphql_client.enums import OrderStatus
+from architect_py.scalars import OrderDir
+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.bid_price
+assert best_bid is not None
+limit_price = best_bid * Decimal(0.8)
+quantity = Decimal(1)
+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=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}")

scripts/generate_functions_md.py

@@ -0,0 +1,164 @@
+import ast
+import re
+import sys
+from collections import defaultdict
+
+
+def extract_sections(source_lines):
+    """
+    Look for section header blocks that look like:
+
+        # ------------------------------------------------------------
+        # Some Section Name
+        # ------------------------------------------------------------
+
+    Returns a list of tuples (section_name, lineno) where lineno is the
+    line number (1-indexed) of the section title.
+    """
+    sections = []
+    # Regex for a dashed line
+    dashed_re = re.compile(r"^\s*#\s*-{10,}\s*$")
+    # Regex for a section title line (should start with "#")
+    title_re = re.compile(r"^\s*#\s*(.+\S)\s*$")
+
+    i = 0
+    while i < len(source_lines):
+        if dashed_re.match(source_lines[i]):
+            if i + 1 < len(source_lines) and title_re.match(source_lines[i + 1]):
+                groups = title_re.match(source_lines[i + 1])
+                if groups is not None:
+                    section_name = groups.group(1).strip()
+                else:
+                    continue
+                # Check that the next line (i+2) is also a dashed line
+                if i + 2 < len(source_lines) and dashed_re.match(source_lines[i + 2]):
+                    sections.append(
+                        (section_name, i + 2)
+                    )  # record line number of closing dashed line, or i+1 as desired
+                    i += 3
+                    continue
+        i += 1
+    return sections
+
+
+def find_section_for_lineno(lineno, sections):
+    """
+    Given a line number (1-indexed) and a list of sections (name, lineno),
+    return the name of the last section that occurs before the given line number.
+    If none found, return "No Section".
+    """
+    candidate = None
+    for name, sec_line in sections:
+        if sec_line < lineno:
+            candidate = name
+        else:
+            break
+    return candidate if candidate is not None else "No Section"
+
+
+def get_asyncclient_methods(filename):
+    with open(filename, "r", encoding="utf-8") as f:
+        source = f.read()
+    source_lines = source.splitlines()
+    # Extract sections from source lines
+    sections = extract_sections(source_lines)
+
+    tree = ast.parse(source, filename)
+    methods = []  # list of tuples (section, func_name, doc_summary, lineno)
+
+    # Walk the AST to find the class AsyncClient
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == "AsyncClient":
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    # Exclude typing overloads
+                    is_fn_overload = False
+                    for decorator in item.decorator_list:
+                        decorator_name = ""
+                        if isinstance(decorator, ast.Call):
+                            decorator_name = (
+                                decorator.func.attr
+                                if isinstance(decorator.func, ast.Attribute)
+                                else decorator.func.id
+                            )
+                        else:
+                            decorator_name = (
+                                decorator.attr
+                                if isinstance(decorator, ast.Attribute)
+                                else decorator.id
+                            )
+                        if decorator_name == "overload":
+                            is_fn_overload = True
+
+                    if is_fn_overload:
+                        continue
+
+                    # Get docstring using ast.get_docstring
+                    doc = ast.get_docstring(item)
+                    if doc:
+                        # Extract the first non-empty line from the docstring
+                        first_line = next(
+                            (line.strip() for line in doc.splitlines() if line.strip()),
+                            "",
+                        )
+                    else:
+                        first_line = ""
+                    section = find_section_for_lineno(item.lineno, sections)
+                    methods.append((section, item.name, first_line, item.lineno))
+            break  # found our class, stop searching
+    return methods
+
+
+def group_methods_by_section(methods):
+    grouped = defaultdict(list)
+    for section, name, summary, lineno in methods:
+        grouped[section].append((name, summary, lineno))
+    # Optionally sort sections by the lowest lineno
+    return dict(grouped)
+
+
+def main(filename):
+    methods = get_asyncclient_methods(filename)
+    grouped = group_methods_by_section(methods)
+    # For predictable order, sort sections by the minimum line number among its methods
+    sorted_sections = sorted(
+        grouped.items(),
+        key=lambda item: min(m[2] for m in grouped[item[0]]) if grouped[item[0]] else 0,
+    )
+    # Alternatively, sort by section name alphabetically:
+    # sorted_sections = sorted(grouped.items())
+    for section, funcs in sorted_sections:
+        emoji = emoji_dict.get(section, "")
+        if emoji == "":
+            raise ValueError(f'Section "{section}" does not have an emoji.')
+        print(f"### {emoji} {section}")
+        print()
+        # Sort functions by their line number
+        for name, summary, lineno in sorted(funcs, key=lambda x: x[2]):
+            # Exclude private methods
+            if name.startswith("__"):
+                continue
+            # Only output if summary is non-empty
+            if summary:
+                if summary.startswith("@deprecated"):
+                    continue
+                print(f"- **`{name}`**: {summary}")
+            else:
+                print(f"- **`{name}`**")
+        print("\n---\n")
+
+
+emoji_dict: dict[str, str] = {
+    "Initialization and configuration": "🚀",
+    "Symbology": "🔍",
+    "Portfolio management": "💹",
+    "Order management": "📝",
+    "Order entry": "📣",
+    "Marketdata": "🧮",
+}
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python extract_methods.py <filename>")
+    else:
+        main(sys.argv[1])