architect-py 5.1.5__py3-none-any.whl → 5.2.0__py3-none-any.whl

examples/external_cpty.py

@@ -1,77 +1,83 @@
-import time
-from concurrent import futures
-from decimal import Decimal
-from typing import Iterator
-
-import grpc
+import asyncio
+import logging
+import random
+import string
 
 from architect_py import (
+    Cancel,
     CptyLoginRequest,
     CptyLogoutRequest,
-    ExecutionInfo,
-    MinOrderQuantityUnit,
-    SimpleDecimal,
-    Unit,
-)
-from architect_py.grpc.models.Cpty.CptyResponse import Symbology
-from architect_py.grpc.models.Orderflow.OrderflowRequest import CancelOrder, PlaceOrder
-from architect_py.grpc.server import (
-    CptyServicer,
-    OrderflowServicer,
-    add_CptyServicer_to_server,
-    add_OrderflowServicer_to_server,
+    Order,
 )
+from architect_py.async_cpty import *
+
+
+class ExampleCpty(AsyncCpty):
+    def __init__(self):
+        super().__init__("EXAMPLE")
+
+    async def on_login(self, request: CptyLoginRequest):
+        print(
+            f"👋 got login request from trader={request.trader} and account={request.account}"
+        )
+
+    async def on_logout(self, request: CptyLogoutRequest):
+        print("👋 got logout request")
+
+    async def on_place_order(self, order: Order):
+        # pretend we're connected to something, ack the order within 1s,
+        # then randomly out or fill the order after 3s
+        print(f"🎟️ place order: {order}")
+        asyncio.create_task(mock_order_lifecycle(self, order))
 
+    async def on_cancel_order(
+        self, cancel: Cancel, _original_order: Optional[Order] = None
+    ):
+        self.reject_cancel(
+            cancel.cancel_id,
+            reject_reason="cancels always get rejected in this example",
+        )
+
+    async def get_open_orders(self) -> Sequence[Order]:
+        return []
+
+
+def random_id(length=10):
+    CHARS = string.ascii_uppercase + string.digits
+    return "".join(random.choice(CHARS) for _ in range(length))
 
-class MockCptyServicer(CptyServicer, OrderflowServicer):
-    def Cpty(self, request_iterator: Iterator, context):
-        context.set_code(grpc.StatusCode.OK)
-        context.send_initial_metadata({})
-        # send symbology
-        yield Symbology(
-            execution_info={
-                "FOO Crypto/USD": {
-                    "MOCK": ExecutionInfo(
-                        execution_venue="MOCK",
-                        exchange_symbol=None,
-                        tick_size=SimpleDecimal(Decimal("0.01")),
-                        step_size=Decimal("0.1"),
-                        min_order_quantity=Decimal(0),
-                        min_order_quantity_unit=MinOrderQuantityUnit(Unit.base),
-                        is_delisted=False,
-                        initial_margin=None,
-                        maintenance_margin=None,
-                    ),
-                }
-            }
+
+async def mock_order_lifecycle(cpty: ExampleCpty, order: Order):
+    await asyncio.sleep(1)
+    exchange_order_id = random_id()
+    print(f"🎟️ ack order: {order.id} with exchange_order_id={exchange_order_id}")
+    cpty.ack_order(order.id, exchange_order_id=exchange_order_id)
+
+    await asyncio.sleep(3)
+    if random.random() < 0.5:
+        now = datetime.now()
+        print(f"🎟️ fill order: {order.id}")
+        cpty.fill_order(
+            order_id=order.id,
+            exchange_fill_id=random_id(),
+            dir=order.dir,
+            price=Decimal(13.37),
+            quantity=order.quantity,
+            symbol=order.symbol,
+            trade_time=now,
+            account=order.account,
+            is_taker=True,
         )
-        for req in request_iterator:
-            if isinstance(req, CptyLoginRequest):
-                print("login message received", req)
-            elif isinstance(req, CptyLogoutRequest):
-                print("logout message received", req)
-            elif isinstance(req, PlaceOrder):
-                print("place_order message received", req)
-            elif isinstance(req, CancelOrder):
-                print("cancel_order message received", req)
-
-    def SubscribeOrderflow(self, request, context):
-        context.set_code(grpc.StatusCode.OK)
-        context.send_initial_metadata({})
-        time.sleep(100)
-
-
-def serve():
-    thread_pool = futures.ThreadPoolExecutor(max_workers=10)
-    server = grpc.server(thread_pool)
-    servicer = MockCptyServicer()
-    add_CptyServicer_to_server(servicer, server)
-    add_OrderflowServicer_to_server(servicer, server)
-    server.add_insecure_port("[::]:50051")
-    server.start()
-    print("server started on port 50051")
-    server.wait_for_termination()
+    else:
+        print(f"🎟️ out order: {order.id}")
+        cpty.out_order(order.id, canceled=False)
+
+
+async def serve():
+    cpty = ExampleCpty()
+    await cpty.serve("[::]:50051")
 
 
 if __name__ == "__main__":
-    serve()
+    logging.basicConfig(level=logging.DEBUG)
+    asyncio.run(serve())

examples/funding_rate_mean_reversion_algo.py

@@ -151,14 +151,14 @@ async def print_info(c: AsyncClient):
 async def main():
     c = await connect_async_client()
 
-    orderflow_manager = await c.orderflow()
-    await orderflow_manager.start()
+    orderflow_channel = await c.orderflow()
+    await orderflow_channel.start()
 
     await asyncio.gather(
         update_marketdata(c),
-        step_to_target_position(c, orderflow_manager),
+        step_to_target_position(c, orderflow_channel),
         print_info(c),
-        subscribe_and_print_orderflow(c, orderflow_manager),
+        subscribe_and_print_orderflow(c, orderflow_channel),
     )
     await c.close()
 

examples/order_sending.py

@@ -22,7 +22,7 @@ async def search_symbol(c: AsyncClient) -> tuple[str, TradableProduct]:
 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)
+    snapshot = await client.get_l1_book_snapshot(symbol=symbol, venue=venue)
     if snapshot is None:
         return ValueError(f"Market snapshot for {symbol} is None")
 
@@ -34,7 +34,7 @@ async def test_send_order(client: AsyncClient, account: str):
     d = datetime.now(tz=timezone.utc) + timedelta(days=1)
     gtd = TimeInForce.GTD(d)
 
-    order = await client.place_limit_order(
+    order = await client.place_order(
         symbol=symbol,
         dir=OrderDir.BUY,
         quantity=best_bid_quantity,
@@ -82,7 +82,7 @@ async def send_NQ_buy_for_mid(client: AsyncClient, account: str):
     if snapshot is None or snapshot.best_ask is None or snapshot.best_bid is None:
         return ValueError(f"Market snapshot for {NQ_lead_future} is None")
 
-    order = await client.place_limit_order(
+    order = await client.place_order(
         symbol=NQ_lead_future,
         dir=OrderDir.BUY,
         quantity=Decimal(1),

examples/orderflow_channel.py

@@ -1,56 +1,75 @@
-# """
-# Example of using a bidirectional orderflow channel with the Architect OEMS.
-
-# This connection style is ~equivalent to having a websocket.
-
-# This code example sends a series of orders to Architect while concurrently
-# listening to orderflow events.  Compare to `examples/orderflow_streaming.py`,
-# which accomplishes the same thing but using a separate asyncio task.
-# """
-
-# import asyncio
-# from decimal import Decimal
-
-# from architect_py import AsyncClient, OrderDir, PlaceOrderRequest
-# from architect_py.grpc.models.Orderflow.OrderflowRequest import PlaceOrder
-
-# from .config import connect_async_client
-
-
-# async def send_orders(client: AsyncClient):
-#     symbol = await client.get_front_future("ES CME Futures")
-#     print(f"symbol={symbol}")
-
-#     while True:
-#         await asyncio.sleep(1)
-#         snap = await client.get_l1_book_snapshot(symbol, "CME")
-#         if snap.best_ask is not None:
-#             limit_price = snap.best_ask[0]
-#             print(f"\nPlacing buy order at {limit_price}\n")
-#             try:
-#                 req = PlaceOrderRequest.new(
-#                     symbol=symbol,
-#                     execution_venue="CME",
-#                     dir=OrderDir.BUY,
-#                     quantity=Decimal(1),
-#                     limit_price=limit_price,
-#                     post_only=True,
-#                     time_in_force="DAY",
-#                     order_type="LIMIT",
-#                 )
-#                 print(f"req={req}")
-#                 yield PlaceOrder(req)
-#             except Exception as e:
-#                 print(f"Error placing order: {e}")
-#         else:
-#             print("\nNo ask price from snapshot, doing nothing\n")
-
-
-# async def main():
-#     client = await connect_async_client()
-
-#     async for event in client.orderflow(send_orders(client)):
-#         print(f" --> {event}")
-
-
-# asyncio.run(main())
+"""
+Example of using a bidirectional orderflow channel with the Architect OEMS.
+
+This connection style is ~equivalent to having a websocket.
+
+This code example sends a series of orders to Architect while concurrently
+listening to orderflow events.  Compare to `examples/orderflow_streaming.py`,
+which accomplishes the same thing but using a separate asyncio task.
+
+
+See funding_rate_mean_reversion_algo.py for a more complete example of
+using the orderflow channel to implement a trading strategy.
+"""
+
+import asyncio
+from decimal import Decimal
+
+from architect_py import (
+    AsyncClient,
+    OrderDir,
+    OrderType,
+    TimeInForce,
+)
+from architect_py.grpc.orderflow import OrderflowChannel, PlaceOrder
+
+from .config import connect_async_client
+
+
+async def send_orders(client: AsyncClient, orderflow_channel: OrderflowChannel):
+    symbol = await client.get_front_future("ES CME Futures")
+    print(f"symbol={symbol}")
+
+    while True:
+        await asyncio.sleep(1)
+        snap = await client.get_l1_book_snapshot(symbol, "CME")
+        if snap.best_ask is not None:
+            limit_price = snap.best_ask[0]
+            print(f"\nPlacing buy order at {limit_price}\n")
+            try:
+                # can also CancelOrder
+                req = PlaceOrder.new(
+                    symbol=symbol,
+                    execution_venue="CME",
+                    dir=OrderDir.BUY,
+                    quantity=Decimal(1),
+                    limit_price=limit_price,
+                    post_only=True,
+                    time_in_force=TimeInForce.DAY,
+                    order_type=OrderType.LIMIT,
+                )
+                print(f"req={req}")
+                await orderflow_channel.send(req)
+            except Exception as e:
+                print(f"Error placing order: {e}")
+        else:
+            print("\nNo ask price from snapshot, doing nothing\n")
+
+
+async def read_events(orderflow_channel: OrderflowChannel):
+    async for event in orderflow_channel:
+        print(f" --> {event}")
+
+
+async def main():
+    client = await connect_async_client()
+
+    orderflow_channel = await client.orderflow()
+
+    await asyncio.gather(
+        send_orders(client, orderflow_channel),
+        read_events(orderflow_channel),
+    )
+
+
+asyncio.run(main())

examples/stream_l1_marketdata.py

@@ -8,8 +8,10 @@ from .config import connect_async_client
 async def main():
     c: AsyncClient = await connect_async_client()
 
+    ES_front_future = await c.get_front_future("ES CME Futures")
+
     async for snap in c.stream_l1_book_snapshots(
-        symbols=[TradableProduct("ES 20250620 CME Future/USD")],
+        symbols=[TradableProduct(ES_front_future)],
         venue="CME",
     ):
         best_bid_s = "<no bid>"

examples/stream_l2_marketdata.py

@@ -29,7 +29,9 @@ async def print_l2_book(c: AsyncClient, symbol: TradableProduct, venue: str):
 
 async def main():
     c: AsyncClient = await connect_async_client()
-    market_symbol = TradableProduct("ES 20250620 CME Future/USD")
+
+    ES_front_future = await c.get_front_future("ES CME Futures")
+    market_symbol = TradableProduct(ES_front_future)
     venue = "CME"
     await print_l2_book(c, market_symbol, venue=venue)
 

examples/tutorial_async.py

@@ -1,7 +1,7 @@
 import asyncio
 from decimal import Decimal
 
-from architect_py import OrderDir, OrderStatus, TradableProduct
+from architect_py import OrderDir, OrderStatus, OrderType, TradableProduct
 
 from .config import connect_async_client
 
@@ -47,10 +47,11 @@ async def main():
         )
         == "y"
     ):
-        order = await c.place_limit_order(
+        order = await c.place_order(
             symbol=market,
             execution_venue=execution_venue,
             dir=OrderDir.BUY,
+            order_type=OrderType.LIMIT,
             quantity=quantity,
             limit_price=limit_price,
             account=str(account_id),

examples/tutorial_sync.py

@@ -2,7 +2,7 @@ import pprint
 import time
 from decimal import Decimal
 
-from architect_py import OrderDir, OrderStatus
+from architect_py import OrderDir, OrderStatus, OrderType
 from architect_py.utils.nearest_tick import TickRoundMethod
 
 from .config import connect_client
@@ -32,7 +32,7 @@ pprint.pp(product_info)
 # 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)
+market_snapshot = c.get_l1_book_snapshot(symbol=symbol, venue=venue)
 
 pprint.pp(market_snapshot)
 
@@ -66,10 +66,11 @@ 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(
+    order = c.place_order(
         symbol=symbol,
         execution_venue=venue,
         dir=OrderDir.BUY,
+        order_type=OrderType.LIMIT,
         quantity=best_bid_quantity,
         limit_price=limit_price,
         account=account.account.name,

scripts/add_imports_to_inits.py

@@ -115,7 +115,9 @@ def main(architect_path: Path, output: Path):
 
     unique = sorted(set(model_all))
     model_lines.append("")
-    model_lines.append(f"__all__ = [{', '.join(f'"{n}"' for n in model_all)}]")
+
+    model_lines_all_list = ", ".join(f'"{n}"' for n in model_all)
+    model_lines.append(f"__all__ = [{model_lines_all_list}]")
     model_lines.append("")
 
     (models_root / "__init__.py").write_text("\n".join(model_lines))
@@ -123,7 +125,9 @@ def main(architect_path: Path, output: Path):
     # 3) write __all__
     unique = sorted(set(all_names))
     import_lines.append("")  # blank line
-    import_lines.append(f"__all__ = [{', '.join(f'"{n}"' for n in unique)}]")
+
+    import_lines_all_list = ", ".join(f'"{n}"' for n in unique)
+    import_lines.append(f"__all__ = [{import_lines_all_list}]")
 
     import_lines.append("")  # blank line
 

scripts/generate_functions_md.py

@@ -129,6 +129,7 @@ def main(filename):
     )
     # Alternatively, sort by section name alphabetically:
     # sorted_sections = sorted(grouped.items())
+    print("# Client Methods")
     for section, funcs in sorted_sections:
         emoji = emoji_dict.get(section, "")
         if emoji == "":
@@ -138,7 +139,7 @@ def main(filename):
         # Sort functions by their line number
         for name, summary, lineno in sorted(funcs, key=lambda x: x[2]):
             # Exclude private methods
-            if name.startswith("__"):
+            if name.startswith("_"):
                 continue
             # Only output if summary is non-empty
             if summary: