architect-py 5.0.0b1__py3-none-any.whl → 5.0.0b3__py3-none-any.whl

examples/funding_rate_mean_reversion_algo.py

@@ -7,20 +7,19 @@ 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_client.definitions import TimeInForceEnum
-from architect_py.grpc_client.Marketdata.TickerRequest import TickerRequest
-from architect_py.grpc_client.Oms.PlaceOrderRequest import PlaceOrderRequestType
-from architect_py.grpc_client.Orderflow.Orderflow import (
+from architect_py.grpc.models.definitions import OrderType, TimeInForceEnum
+from architect_py.grpc.models.Orderflow.Orderflow import (
     TaggedOrderAck,
     TaggedOrderOut,
     TaggedOrderReject,
 )
-from architect_py.grpc_client.Orderflow.OrderflowRequest import (
+from architect_py.grpc.models.Orderflow.OrderflowRequest import (
     OrderflowRequest,
     PlaceOrder,
 )
-from architect_py.scalars import OrderDir, TradableProduct
 
 from .common import connect_async_client
 
@@ -52,9 +51,8 @@ class OrderflowRequester:
 
 
 async def update_marketdata(c: AsyncClient):
-    ticker_request = TickerRequest(symbol=tradable_product)
-    s = c.grpc_client.subscribe(ticker_request)
-    async for ticker in s:
+    while True:
+        ticker = await c.get_ticker(tradable_product, venue)
         if ticker.funding_rate:
             global current_funding_rate
             global target_position
@@ -76,13 +74,14 @@ async def update_marketdata(c: AsyncClient):
         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.grpc_client.subscribe_orderflow_stream(orderflow_requester)
+        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.
@@ -126,7 +125,7 @@ async def step_to_target_position(
                     execution_venue=None,
                     limit_price=best_ask_price,
                     time_in_force=TimeInForceEnum.DAY,
-                    place_order_request_type=PlaceOrderRequestType.LIMIT,
+                    order_type=OrderType.LIMIT,
                 )
 
         elif current_position > target_position:
@@ -141,7 +140,7 @@ async def step_to_target_position(
                     execution_venue=None,
                     limit_price=best_bid_price,
                     time_in_force=TimeInForceEnum.DAY,
-                    place_order_request_type=PlaceOrderRequestType.LIMIT,
+                    order_type=OrderType.LIMIT,
                 )
 
         if order is not None:
@@ -159,14 +158,9 @@ async def print_info(c: AsyncClient):
         )
         pos = Decimal(0)
         for account in account_summaries:
-            for balance in account.balances:
-                if balance.product is None:
-                    name = "UNKNOWN NAME"
-                else:
-                    name = balance.product
-                print(f"balance for {name}: {balance.balance}")
-                if name and balance.balance is not None:
-                    pos += balance.balance
+            for name, balance in account.balances.items():
+                print(f"balance for {name}: {balance}")
+                pos += balance
         global current_position
         current_position = pos
         print("---")

examples/order_sending.py

@@ -1,31 +1,20 @@
 import asyncio
 import logging
+from datetime import datetime, timedelta, timezone
 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
+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__)
 
-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]:
+async def search_symbol(c: AsyncClient) -> tuple[str, TradableProduct]:
     venue = "CME"
-    markets = await client.search_symbols(
+    markets = await c.search_symbols(
         search_string="ES",
         execution_venue=venue,
     )
@@ -33,27 +22,32 @@ async def search_symbol() -> tuple[str, TradableProduct]:
     return venue, market
 
 
-async def test_send_order():
-    venue, symbol = await search_symbol()
+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.ask_price is None or snapshot.bid_price is None:
+    if snapshot.best_ask is None or snapshot.best_bid is None:
         return ValueError(f"Market snapshot for {symbol} is None")
 
-    order = await client.send_limit_order(
+    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=Decimal(1),
+        quantity=best_bid_quantity,
         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,
+        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}")
 
@@ -64,12 +58,12 @@ async def test_send_order():
     return cancel
 
 
-async def test_cancel_all_orders():
+async def test_cancel_all_orders(client: AsyncClient):
     await client.cancel_all_orders()
 
 
-async def test_send_market_pro_order():
-    venue, symbol = await search_symbol()
+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(
@@ -77,13 +71,18 @@ async def test_send_market_pro_order():
         execution_venue=venue,
         odir=OrderDir.BUY,
         quantity=Decimal(1),
-        account=ACCOUNT,
-        time_in_force=TimeInForce.IOC,
+        account=account,
+        time_in_force=TimeInForceEnum.IOC,
     )
 
 
 async def main():
-    await test_send_market_pro_order()
+    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__":

examples/stream_l1_marketdata.py

@@ -1,7 +1,7 @@
 import asyncio
 
 from architect_py.async_client import AsyncClient
-from architect_py.scalars import TradableProduct
+from architect_py.common_types.tradable_product import TradableProduct
 
 from .common import connect_async_client
 
@@ -9,7 +9,7 @@ from .common import connect_async_client
 async def main():
     c: AsyncClient = await connect_async_client()
 
-    async for snap in c.subscribe_l1_book_stream(
+    async for snap in c.stream_l1_book_snapshots(
         symbols=[TradableProduct("ES 20250620 CME Future/USD")],
         venue="CME",
     ):

examples/stream_l2_marketdata.py

@@ -1,7 +1,7 @@
 import asyncio
 
 from architect_py.async_client import AsyncClient
-from architect_py.scalars import TradableProduct
+from architect_py.common_types.tradable_product import TradableProduct
 
 from .common import connect_async_client
 
@@ -30,8 +30,6 @@ async def print_l2_book(c: AsyncClient, symbol: TradableProduct, venue: str):
 
 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)

examples/trades.py

@@ -1,8 +1,8 @@
 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 architect_py.scalars import TradableProduct
 
 from .common import connect_async_client
 
@@ -11,7 +11,7 @@ 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"):
+        async for trade in c.stream_trades(market_id, venue="COINBASE"):
             print(trade)
     except GraphQLClientHttpError as e:
         print(e.status_code)

examples/tutorial_async.py

@@ -2,8 +2,8 @@ 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 architect_py.scalars import TradableProduct
 from examples.common import connect_async_client
 
 
@@ -19,8 +19,8 @@ async def main():
     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}")
+    print(f"Best bid: {market_snapshot.best_bid}")
+    print(f"Best ask: {market_snapshot.best_ask}")
 
     # List your FCM accounts
     print()
@@ -32,10 +32,12 @@ async def main():
     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:
+    if (best_bid := market_snapshot.best_bid) is not None:
+        bid_px = best_bid[0]
+    else:
         raise ValueError("No bid price available")
-    limit_price = best_bid - Decimal(100)
+
+    limit_price = bid_px - Decimal(100)
     quantity = Decimal(1)
     account = accounts[0]
     order = None
@@ -46,7 +48,7 @@ async def main():
         )
         == "y"
     ):
-        order = await c.send_limit_order(
+        order = await c.place_limit_order(
             symbol=market,
             execution_venue=execution_venue,
             odir=OrderDir.BUY,

examples/tutorial_sync.py

@@ -2,8 +2,8 @@ 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.scalars import OrderDir
 from architect_py.utils.nearest_tick import TickRoundMethod
 
 from .common import confirm, connect_client, print_book, print_open_orders
@@ -56,10 +56,10 @@ orders = c.get_open_orders()
 print_open_orders(orders)
 
 # Place a limit order 20% below the best bid
-best_bid = market_snapshot.bid_price
+best_bid = market_snapshot.best_bid
 assert best_bid is not None
-limit_price = best_bid * Decimal(0.8)
-quantity = Decimal(1)
+best_bid_price, best_bid_quantity = best_bid
+limit_price = best_bid_price * Decimal(0.8)
 account = accounts[0]
 order = None
 
@@ -70,7 +70,7 @@ if confirm(
         symbol=symbol,
         execution_venue=venue,
         odir=OrderDir.BUY,
-        quantity=quantity,
+        quantity=best_bid_quantity,
         limit_price=limit_price,
         account=account.account.name,
         price_round_method=TickRoundMethod.ROUND,

scripts/generate_functions_md.py

@@ -79,13 +79,15 @@ def get_asyncclient_methods(filename):
                             decorator_name = (
                                 decorator.func.attr
                                 if isinstance(decorator.func, ast.Attribute)
-                                else decorator.func.id
+                                else getattr(decorator.func, "id", "")
                             )
                         else:
                             decorator_name = (
                                 decorator.attr
                                 if isinstance(decorator, ast.Attribute)
                                 else decorator.id
+                                if isinstance(decorator, ast.Name)
+                                else ""
                             )
                         if decorator_name == "overload":
                             is_fn_overload = True

scripts/generate_sync_interface.py

@@ -1,9 +1,10 @@
+import argparse
 import collections.abc
 import inspect
 import types
 from decimal import Decimal
 from enum import Enum
-from typing import Any, Sequence, Union, get_args, get_origin
+from typing import Annotated, Any, Sequence, Union, get_args, get_origin
 
 from architect_py.async_client import AsyncClient
 from architect_py.graphql_client.base_model import UnsetType
@@ -19,6 +20,12 @@ def format_type_hint_with_generics(type_hint) -> str:
 
     origin = get_origin(type_hint)
 
+    if origin is Annotated:
+        annotated_args = get_args(type_hint)
+        if annotated_args:
+            return format_type_hint_with_generics(annotated_args[0])
+        return "Any"
+
     # Handle `|` unions (Python 3.10+)
     if isinstance(
         type_hint, types.UnionType
@@ -88,9 +95,9 @@ def autogenerate_protocol(cls, protocol_name: str) -> str:
     Returns:
         A string representing the Protocol definition.
     """
-    methods = {}
-    method_decorators = {}
-    attributes = {}
+    methods: dict[str, inspect.Signature] = {}
+    method_decorators: dict[str, list[str]] = {}
+    attributes: dict[str, Any] = {}
 
     # Inspect class members
     for name, member in inspect.getmembers(cls):
@@ -139,7 +146,7 @@ def autogenerate_protocol(cls, protocol_name: str) -> str:
         "from typing import Any, Union",
         "from .graphql_client import *",
         "from .async_client import *",
-        "\n",
+        "from .grpc.models.definitions import *",
         f"class {protocol_name}:",
     ]
 
@@ -151,14 +158,15 @@ def autogenerate_protocol(cls, protocol_name: str) -> str:
 
     # Add methods
     for name, signature in methods.items():
-        if (
-            name.startswith("subscribe")
-            or name.startswith("stream")
-            or name.startswith("unsubscribe")
-            or name == "connect"
+        if any(
+            keyword in name
+            for keyword in ("subscribe", "stream", "unsubscribe", "connect")
         ):
             continue
 
+        if "async" in str(signature).lower():
+            continue
+
         # for decorators like @staticmethod and @classmethod
         if name in method_decorators:
             for deco in method_decorators[name]:
@@ -204,4 +212,15 @@ def autogenerate_protocol(cls, protocol_name: str) -> str:
 
 
 if __name__ == "__main__":
-    print(autogenerate_protocol(AsyncClient, "ClientProtocol"))
+    parser = argparse.ArgumentParser(description="Process gRPC service definitions")
+    parser.add_argument(
+        "--file_path",
+        type=str,
+        default="architect_py/grpc_client",
+        help="Path to the Python folder with the gRPC service definitions",
+    )
+    args = parser.parse_args()
+    protocol: str = autogenerate_protocol(AsyncClient, "ClientProtocol")
+
+    with open(args.file_path, "w") as f:
+        f.write(protocol)

scripts/postprocess_grpc.py

@@ -207,6 +207,9 @@ def create_tagged_subtypes_for_variant_types(content: str, json_data: dict) -> s
     if tag_field is None:
         return content
 
+    if "oneOf" not in json_data:
+        return content
+
     # Build a mapping from base type name to its variants.
     tag_field_map: dict[str, List[Tuple[str, str]]] = defaultdict(list)
     for p in json_data["oneOf"]:
@@ -319,30 +322,35 @@ def fix_lines(content: str) -> str:
     return content
 
 
-def add_post_processing_to_loosened_types(content: str, json_data: dict) -> str:
+def add_post_processing_to_unflattened_types(content: str, json_data: dict) -> str:
     """
     Adds a __post_init__ method to the flattened types to enforce field requirements.
     """
-    enum_tag = json_data.get("enum_tag")
-    if enum_tag is None:
+    enum_variant_to_other_required_keys: dict[str, List[str]] = json_data.get(
+        "enum_variant_to_other_required_keys", {}
+    )
+    if len(enum_variant_to_other_required_keys) == 0:
         return content
 
+    enum_tag = json_data[
+        "tag_field"
+    ]  # should not be empty if enum_variant_to_other_required_keys is not empty
+
     class_title = json_data["title"]
 
     properties = json_data["properties"]
-    enum_tag_to_other_required_keys: dict[str, List[str]] = json_data[
-        "enum_tag_to_other_required_keys"
-    ]
 
     lines = content.splitlines(keepends=True)
     # Append __post_init__ method at the end
     lines.append("\n    def __post_init__(self):\n")
 
-    common_keys = set.intersection(*map(set, enum_tag_to_other_required_keys.values()))
-    union_keys = set.union(*map(set, enum_tag_to_other_required_keys.values()))
+    common_keys = set.intersection(
+        *map(set, enum_variant_to_other_required_keys.values())
+    )
+    union_keys = set.union(*map(set, enum_variant_to_other_required_keys.values()))
 
     for i, (enum_value, required_keys) in enumerate(
-        enum_tag_to_other_required_keys.items()
+        enum_variant_to_other_required_keys.items()
     ):
         conditional = "if" if i == 0 else "elif"
         title = properties[enum_tag]["title"]
@@ -429,7 +437,9 @@ def generate_stub(content: str, json_data: dict) -> str:
 """
 
     # If this is a Request file, append additional gRPC info.
-    if json_data.get("tag_field") is not None:
+    if (json_data.get("tag_field") is not None) and (
+        json_data.get("enum_variant_to_other_required_keys") is None
+    ):
         service = json_data["service"]
         rpc_method = json_data["rpc_method"]
         response_type = json_data["response_type"]
@@ -556,7 +566,7 @@ def part_1(py_file_path: str, json_data: dict) -> None:
     content = create_tagged_subtypes_for_variant_types(content, json_data)
     content = fix_lines(content)
     if not py_file_path.endswith("definitions.py"):
-        content = add_post_processing_to_loosened_types(content, json_data)
+        content = add_post_processing_to_unflattened_types(content, json_data)
 
     content = fix_enum_member_names(content, json_data)