architect-py 5.1.3__py3-none-any.whl → 5.1.4rc1__py3-none-any.whl

architect_py/grpc/models/definitions.py

@@ -15,6 +15,12 @@ from msgspec import Meta, Struct
 from .Marketdata.Ticker import Ticker
 
 
+class AccountHistoryGranularity(str, Enum):
+    FiveMinutes = "FiveMinutes"
+    Hourly = "Hourly"
+    Daily = "Daily"
+
+
 AccountIdOrName = str
 
 
@@ -177,6 +183,8 @@ class CandleWidth(int, Enum):
     OneSecond = 1
     FiveSecond = 5
     OneMinute = 60
+    TwoMinute = 120
+    ThreeMinute = 180
     FifteenMinute = 900
     OneHour = 3600
     OneDay = 86400
@@ -454,6 +462,7 @@ class OrderRejectReason(str, Enum):
     InsufficientCash = "InsufficientCash"
     InsufficientMargin = "InsufficientMargin"
     NotEasyToBorrow = "NotEasyToBorrow"
+    InvalidOrder = "InvalidOrder"
     Unknown = "Unknown"
 
 
@@ -501,6 +510,7 @@ class OrderType(str, Enum):
     LIMIT = "LIMIT"
     STOP_LOSS_LIMIT = "STOP_LOSS_LIMIT"
     TAKE_PROFIT_LIMIT = "TAKE_PROFIT_LIMIT"
+    BRACKET = "BRACKET"
 
 
 class ProductCatalogInfo(Struct, omit_defaults=True):
@@ -789,6 +799,42 @@ class Statement(Struct, omit_defaults=True):
 TraderIdOrEmail = str
 
 
+class TriggerLimitOrderType(Struct, omit_defaults=True):
+    p: Annotated[Decimal, Meta(title="limit_price")]
+    tp: Annotated[Decimal, Meta(title="trigger_price")]
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        limit_price: Decimal,
+        trigger_price: Decimal,
+    ):
+        return cls(
+            limit_price,
+            trigger_price,
+        )
+
+    def __str__(self) -> str:
+        return f"TriggerLimitOrderType(limit_price={self.p},trigger_price={self.tp})"
+
+    @property
+    def limit_price(self) -> Decimal:
+        return self.p
+
+    @limit_price.setter
+    def limit_price(self, value: Decimal) -> None:
+        self.p = value
+
+    @property
+    def trigger_price(self) -> Decimal:
+        return self.tp
+
+    @trigger_price.setter
+    def trigger_price(self, value: Decimal) -> None:
+        self.tp = value
+
+
 UserId = str
 
 
@@ -868,6 +914,9 @@ class FillKind(int, Enum):
     Correction = 2
 
 
+HumanDuration = str
+
+
 class Unit(str, Enum):
     base = "base"
     quote = "quote"
@@ -1159,6 +1208,17 @@ SnapshotOrUpdateForStringAndString = Union[
 ]
 
 
+class SpreaderPhase(str, Enum):
+    ScanningForTakes = "ScanningForTakes"
+    AwaitingOrderResults = "AwaitingOrderResults"
+    OrderLockout = "OrderLockout"
+    NoBbo = "NoBbo"
+    NotEnoughBboSize = "NotEnoughBboSize"
+    DoneOverfilled = "DoneOverfilled"
+    DoneAndFullyHedged = "DoneAndFullyHedged"
+    DoneAndGivingUp = "DoneAndGivingUp"
+
+
 class SimpleDecimal(Struct, omit_defaults=True):
     simple: Decimal
 
@@ -2255,6 +2315,100 @@ SnapshotOrUpdateForStringAndSnapshotOrUpdateForStringAndProductCatalogInfo = Uni
 ]
 
 
+class SpreaderParams(Struct, omit_defaults=True):
+    dir: OrderDir
+    leg1_marketdata_venue: str
+    leg1_price_offset: Decimal
+    leg1_price_ratio: Decimal
+    leg1_quantity_ratio: Decimal
+    leg1_symbol: str
+    leg2_marketdata_venue: str
+    leg2_price_offset: Decimal
+    leg2_price_ratio: Decimal
+    leg2_quantity_ratio: Decimal
+    leg2_symbol: str
+    limit_price: Decimal
+    order_lockout: HumanDuration
+    quantity: Decimal
+    leg1_account: Optional[AccountIdOrName] = None
+    leg1_execution_venue: Optional[str] = None
+    leg2_account: Optional[AccountIdOrName] = None
+    leg2_execution_venue: Optional[str] = None
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        dir: OrderDir,
+        leg1_marketdata_venue: str,
+        leg1_price_offset: Decimal,
+        leg1_price_ratio: Decimal,
+        leg1_quantity_ratio: Decimal,
+        leg1_symbol: str,
+        leg2_marketdata_venue: str,
+        leg2_price_offset: Decimal,
+        leg2_price_ratio: Decimal,
+        leg2_quantity_ratio: Decimal,
+        leg2_symbol: str,
+        limit_price: Decimal,
+        order_lockout: HumanDuration,
+        quantity: Decimal,
+        leg1_account: Optional[AccountIdOrName] = None,
+        leg1_execution_venue: Optional[str] = None,
+        leg2_account: Optional[AccountIdOrName] = None,
+        leg2_execution_venue: Optional[str] = None,
+    ):
+        return cls(
+            dir,
+            leg1_marketdata_venue,
+            leg1_price_offset,
+            leg1_price_ratio,
+            leg1_quantity_ratio,
+            leg1_symbol,
+            leg2_marketdata_venue,
+            leg2_price_offset,
+            leg2_price_ratio,
+            leg2_quantity_ratio,
+            leg2_symbol,
+            limit_price,
+            order_lockout,
+            quantity,
+            leg1_account,
+            leg1_execution_venue,
+            leg2_account,
+            leg2_execution_venue,
+        )
+
+    def __str__(self) -> str:
+        return f"SpreaderParams(dir={self.dir},leg1_marketdata_venue={self.leg1_marketdata_venue},leg1_price_offset={self.leg1_price_offset},leg1_price_ratio={self.leg1_price_ratio},leg1_quantity_ratio={self.leg1_quantity_ratio},leg1_symbol={self.leg1_symbol},leg2_marketdata_venue={self.leg2_marketdata_venue},leg2_price_offset={self.leg2_price_offset},leg2_price_ratio={self.leg2_price_ratio},leg2_quantity_ratio={self.leg2_quantity_ratio},leg2_symbol={self.leg2_symbol},limit_price={self.limit_price},order_lockout={self.order_lockout},quantity={self.quantity},leg1_account={self.leg1_account},leg1_execution_venue={self.leg1_execution_venue},leg2_account={self.leg2_account},leg2_execution_venue={self.leg2_execution_venue})"
+
+
+class SpreaderStatus(Struct, omit_defaults=True):
+    current_spreader_phase: SpreaderPhase
+    leg1_fill_quantity: Decimal
+    leg2_fill_quantity: Decimal
+    implied_spread_vwap: Optional[Decimal] = None
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        current_spreader_phase: SpreaderPhase,
+        leg1_fill_quantity: Decimal,
+        leg2_fill_quantity: Decimal,
+        implied_spread_vwap: Optional[Decimal] = None,
+    ):
+        return cls(
+            current_spreader_phase,
+            leg1_fill_quantity,
+            leg2_fill_quantity,
+            implied_spread_vwap,
+        )
+
+    def __str__(self) -> str:
+        return f"SpreaderStatus(current_spreader_phase={self.current_spreader_phase},leg1_fill_quantity={self.leg1_fill_quantity},leg2_fill_quantity={self.leg2_fill_quantity},implied_spread_vwap={self.implied_spread_vwap})"
+
+
 class Account(Struct, omit_defaults=True):
     id: str
     name: AccountName

architect_py/grpc/orderflow.py

@@ -0,0 +1,138 @@
+import asyncio
+import contextlib
+from typing import TYPE_CHECKING, Any, AsyncGenerator, AsyncIterator, Optional, Union
+
+import grpc.aio
+
+from architect_py.grpc.models.Orderflow.Orderflow import Orderflow
+from architect_py.grpc.models.Orderflow.OrderflowRequest import (
+    OrderflowRequest,
+    OrderflowRequest_route,
+    OrderflowRequestUnannotatedResponseType,
+)
+
+if TYPE_CHECKING:
+    from architect_py.async_client import AsyncClient
+
+_CLOSE_SENTINEL: Any = object()  # internal close marker
+
+
+class OrderflowChannel:
+    """
+    Web-socket–like helper around Architect’s bidirectional Orderflow gRPC stream.
+
+    Must call OrderflowManager.start() to open the stream.
+
+    Example usage 1:
+        om = client.orderflow(queue_size=2048)   # instantiate
+        await om.start()                         # open stream
+
+        await om.place_order(args)
+        update = await om.receive()  # receive a single orderflow update
+        # to receive continuously, either but in a loop or see example usage 2.
+        print("first update:", update)
+
+        await om.close()                         # graceful shutdown, not required
+
+    Example usage 2:
+        async with await client.orderflow() as om:  # om.start() happens automatically
+            async for update in om:  # this will run until the stream is closed
+                print("order update:", update)
+
+    For more advanced usage, see the funding_rate_mean_reversion_algo.py example.
+    """
+
+    def __init__(self, client: "AsyncClient", *, max_queue_size: int = 1024) -> None:
+        self._client = client
+        self._send_q: asyncio.Queue[Union[OrderflowRequest, Any]] = asyncio.Queue(
+            maxsize=max_queue_size
+        )
+        self._receive_q: asyncio.Queue[Orderflow] = asyncio.Queue()
+        self._stream_task: Optional[asyncio.Task[None]] = None
+        self._grpc_call: Optional[
+            grpc.aio.StreamStreamCall[OrderflowRequest, Orderflow]
+        ] = None
+        self._closed = asyncio.Event()
+
+    async def start(self) -> None:
+        """ """
+        if self._stream_task is None:
+            self._stream_task = asyncio.create_task(
+                self._stream_loop(), name="orderflow-stream"
+            )
+
+    async def send(self, req: OrderflowRequest) -> None:
+        """
+        Note that some of the OrderflowRequest types are tagged versions of the classes that exist elsewhere.
+        Only use the TAGGED versions, as the untagged versions will not work with the stream.
+        """
+        await self._send_q.put(req)
+
+    async def receive(self) -> Orderflow:
+        """Await the next Orderflow update from the server."""
+        return await self._receive_q.get()
+
+    async def close(self) -> None:
+        if self._stream_task is None:
+            return
+        await self._send_q.put(_CLOSE_SENTINEL)
+
+        if self._grpc_call is not None:
+            self._grpc_call.cancel()
+
+        self._stream_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await self._stream_task
+        self._stream_task = None
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    def __aiter__(self) -> AsyncGenerator[Orderflow, None]:
+        return self._iter_updates()
+
+    async def _iter_updates(self) -> AsyncGenerator[Orderflow, None]:
+        while not self._closed.is_set():
+            try:
+                yield await self.receive()
+            except asyncio.CancelledError:
+                break
+
+    async def _request_iter(self) -> AsyncIterator[OrderflowRequest]:
+        while True:
+            item = await self._send_q.get()
+            if item is _CLOSE_SENTINEL:
+                break
+            yield item
+
+    async def _stream_loop(self) -> None:
+        try:
+            async for update in self._grpc_orderflow_stream(self._request_iter()):
+                await self._receive_q.put(update)
+        finally:
+            self._closed.set()
+
+    async def _grpc_orderflow_stream(
+        self, request_iterator: AsyncIterator[OrderflowRequest]
+    ) -> AsyncGenerator[Orderflow, None]:
+        """Low-level wrapper around Architect’s gRPC bidirectional stream."""
+        grpc_client = await self._client.core()
+        decoder = grpc_client.get_decoder(OrderflowRequestUnannotatedResponseType)
+
+        stub: grpc.aio.StreamStreamMultiCallable = grpc_client.channel.stream_stream(
+            OrderflowRequest_route,
+            request_serializer=grpc_client.encoder().encode,
+            response_deserializer=decoder.decode,
+        )
+
+        self._grpc_call = stub(
+            request_iterator,
+            metadata=(("authorization", f"Bearer {grpc_client.jwt}"),),
+        )
+
+        async for update in self._grpc_call:
+            yield update

architect_py/tests/test_order_entry.py

@@ -4,18 +4,18 @@ from decimal import Decimal
 import pytest
 
 from architect_py import AsyncClient, OrderDir, TickRoundMethod
+from architect_py.grpc.models.definitions import OrderType
 
 
 @pytest.mark.asyncio
 @pytest.mark.timeout(3)
 async def test_place_limit_order(async_client: AsyncClient):
-    # CR alee: there's no good way to get the front month future
-    symbol = "MET 20250530 CME Future/USD"
     venue = "CME"
-    info = await async_client.get_execution_info(symbol, venue)
+    front_future = await async_client.get_front_future("ES CME Futures", venue)
+    info = await async_client.get_execution_info(front_future, venue)
     assert info is not None
     assert info.tick_size is not None
-    snap = await async_client.get_ticker(symbol, venue)
+    snap = await async_client.get_ticker(front_future, venue)
     assert snap is not None
     assert snap.bid_price is not None
     accounts = await async_client.list_accounts()
@@ -23,14 +23,17 @@ async def test_place_limit_order(async_client: AsyncClient):
 
     # bid far below the best bid
     limit_price = TickRoundMethod.FLOOR(snap.bid_price * Decimal(0.9), info.tick_size)
-    order = await async_client.place_limit_order(
-        symbol=symbol,
+    order = await async_client.place_order(
+        symbol=front_future,
         execution_venue=venue,
         dir=OrderDir.BUY,
         quantity=Decimal(1),
+        order_type=OrderType.LIMIT,
         limit_price=limit_price,
+        post_only=False,
         account=str(account.account.id),
     )
+
     assert order is not None
     await asyncio.sleep(1)
     await async_client.cancel_order(order.id)

architect_py/tests/test_orderflow.py

@@ -1,41 +1,130 @@
-"""
 import asyncio
+from decimal import Decimal
 
 import pytest
 
-from architect_py import AsyncClient
-from architect_py.grpc.models.Orderflow.OrderflowRequest import OrderflowRequest
+from architect_py import *
+from architect_py.grpc.models.Orderflow.Orderflow import TaggedOrderAck
+from architect_py.grpc.models.Orderflow.OrderflowRequest import (
+    CancelOrder,
+    OrderflowRequestUnannotatedResponseType,
+    PlaceOrder,
+)
 
 
-class OrderflowAsyncIterator:
-    queue: list[OrderflowRequest]
-    condition: asyncio.Condition
+@pytest.mark.asyncio
+@pytest.mark.timeout(3)
+async def test_orderflow(async_client: AsyncClient):
+    venue = "CME"
+    front_future = await async_client.get_front_future("ES CME Futures", venue)
+    async with await async_client.orderflow() as om:
+        l1_snapshot = await async_client.get_l1_book_snapshot(front_future, venue=venue)
+        assert l1_snapshot.best_bid is not None
+        assert l1_snapshot.best_ask is not None
+        spread = l1_snapshot.best_ask[0] - l1_snapshot.best_bid[0]
+        price: Decimal = l1_snapshot.best_bid[0] - spread * 10
 
-    def __init__(self):
-        self.queue: list[OrderflowRequest] = []
-        self.condition: asyncio.Condition = asyncio.Condition()
+        accounts = await async_client.list_accounts()
+        account = next(
+            acc.account.name
+            for acc in accounts
+            if not acc.account.name.startswith("RQD")
+        )
 
-    def __aiter__(self):
-        return self
+        await om.send(
+            PlaceOrder.new(
+                dir=OrderDir.BUY,
+                symbol=front_future,
+                time_in_force=TimeInForce.DAY,
+                quantity=Decimal(1),
+                execution_venue=venue,
+                order_type=OrderType.LIMIT,
+                limit_price=price,
+                post_only=False,
+                account=account,
+            )
+        )
+        print("Order placed, waiting for updates...")
+        i = 0
+        async for update in om:
+            assert isinstance(update, OrderflowRequestUnannotatedResponseType)
 
-    async def __anext__(self) -> OrderflowRequest:
-        async with self.condition:
-            while not self.queue:
-                await self.condition.wait()
-            return self.queue.pop(0)
+            if isinstance(update, TaggedOrderAck):
+                await om.send(
+                    CancelOrder(
+                        id=update.id,
+                    )
+                )
+            i += 1
+            if i > 1:
+                break
 
-    async def add_to_queue(self, item: OrderflowRequest):
-        async with self.condition:
-            self.queue.append(item)
-            self.condition.notify()
+    await async_client.cancel_all_orders()
+    await async_client.close()
 
 
 @pytest.mark.asyncio
-@pytest.mark.timeout(10)
-async def test_orderflow(async_client: AsyncClient):
-    oai = OrderflowAsyncIterator()
-    async for of in async_client.orderflow(oai):
-        assert of is not None
-        return
+@pytest.mark.timeout(4)
+async def test_stream_orderflow(async_client: AsyncClient):
+    print("Starting to stream Orderflow events...")
+
+    asyncio.create_task(send_order(async_client))
+    i = 0
+    async for event in async_client.stream_orderflow():
+        print(f"Received Orderflow event: {event}")
+        assert isinstance(event, OrderflowRequestUnannotatedResponseType)
+
+        if isinstance(event, OrderAck):
+            await async_client.cancel_order(event.order_id)
+
+        i += 1
+        if i > 1:
+            break
+
+    await async_client.close()
+
+
+async def send_order(client: AsyncClient):
+    venue = "CME"
+    front_future = await client.get_front_future("ES CME Futures", venue)
+
+    l1_snapshot = await client.get_l1_book_snapshot(front_future, venue=venue)
+    assert l1_snapshot.best_bid is not None
+    assert l1_snapshot.best_ask is not None
+    spread = l1_snapshot.best_ask[0] - l1_snapshot.best_bid[0]
+    price: Decimal = l1_snapshot.best_bid[0] - spread * 10
+
+    accounts = await client.list_accounts()
+    account = next(
+        acc.account.name for acc in accounts if not acc.account.name.startswith("RQD")
+    )
+
+    await asyncio.sleep(0.5)
+    await client.place_order(
+        dir=OrderDir.BUY,
+        symbol=front_future,
+        time_in_force=TimeInForce.DAY,
+        quantity=Decimal(1),
+        execution_venue=venue,
+        order_type=OrderType.LIMIT,
+        limit_price=price,
+        post_only=False,
+        account=account,
+    )
+
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    async_client = loop.run_until_complete(
+        AsyncClient.connect(
+            api_key="",
+            api_secret="",
+            paper_trading=True,
+            endpoint="https://app.architect.co",
+        )
+    )
 
-"""
+    loop.run_until_complete(test_stream_orderflow(async_client))
+    # loop.run_until_complete(test_orderflow(async_client))

{architect_py-5.1.3.dist-info → architect_py-5.1.4rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: architect-py
-Version: 5.1.3
+Version: 5.1.4rc1
 Summary: Python SDK for the Architect trading platform and brokerage.
 Author-email: "Architect Financial Technologies, Inc." <hello@architect.co>
 License-Expression: Apache-2.0