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

architect_py/grpc/models/definitions.py

@@ -12,8 +12,6 @@ from typing import Annotated, Dict, List, Literal, Optional, Union
 
 from msgspec import Meta, Struct
 
-from .Marketdata.Ticker import Ticker
-
 
 class AccountHistoryGranularity(str, Enum):
     FiveMinutes = "FiveMinutes"
@@ -435,6 +433,38 @@ class L2BookDiff(Struct, omit_defaults=True):
         return datetime.fromtimestamp(self.ts)
 
 
+class OptionsTransaction(Struct, omit_defaults=True):
+    clearing_firm_account: str
+    quantity: Decimal
+    timestamp: datetime
+    tradable_product: str
+    transaction_type: str
+    price: Optional[Decimal] = None
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        clearing_firm_account: str,
+        quantity: Decimal,
+        timestamp: datetime,
+        tradable_product: str,
+        transaction_type: str,
+        price: Optional[Decimal] = None,
+    ):
+        return cls(
+            clearing_firm_account,
+            quantity,
+            timestamp,
+            tradable_product,
+            transaction_type,
+            price,
+        )
+
+    def __str__(self) -> str:
+        return f"OptionsTransaction(clearing_firm_account={self.clearing_firm_account},quantity={self.quantity},timestamp={self.timestamp},tradable_product={self.tradable_product},transaction_type={self.transaction_type},price={self.price})"
+
+
 OrderId = Annotated[
     str, Meta(description="System-unique, persistent order identifiers")
 ]
@@ -604,6 +634,11 @@ class ProductCatalogInfo(Struct, omit_defaults=True):
         return f"ProductCatalogInfo(exchange={self.exchange},exchange_product={self.exchange_product},category={self.category},cqg_contract_symbol={self.cqg_contract_symbol},info_url={self.info_url},long_description={self.long_description},multiplier={self.multiplier},price_display_format={self.price_display_format},quote_currency={self.quote_currency},schedule_description={self.schedule_description},settle_method={self.settle_method},short_description={self.short_description},sub_category={self.sub_category})"
 
 
+class PutOrCall(str, Enum):
+    P = "P"
+    C = "C"
+
+
 class RqdAccountStatistics(Struct, omit_defaults=True):
     account_number: str
     account_type: Optional[str] = None
@@ -1120,11 +1155,6 @@ class Unknown(Struct, omit_defaults=True):
         return f"Unknown(product_type={self.product_type})"
 
 
-class PutOrCall(str, Enum):
-    P = "P"
-    C = "C"
-
-
 class SnapshotOrUpdateForStringAndProductCatalogInfo1(Struct, omit_defaults=True):
     snapshot: Dict[str, ProductCatalogInfo]
 
@@ -1955,85 +1985,6 @@ class Fill(Struct, omit_defaults=True):
         self.xid = value
 
 
-class OptionsContract(Struct, omit_defaults=True):
-    expiration: date
-    put_or_call: PutOrCall
-    strike: Decimal
-    ticker: Ticker
-    underlying: str
-    in_the_money: Optional[bool] = None
-
-    # Constructor that takes all field titles as arguments for convenience
-    @classmethod
-    def new(
-        cls,
-        expiration: date,
-        put_or_call: PutOrCall,
-        strike: Decimal,
-        ticker: Ticker,
-        underlying: str,
-        in_the_money: Optional[bool] = None,
-    ):
-        return cls(
-            expiration,
-            put_or_call,
-            strike,
-            ticker,
-            underlying,
-            in_the_money,
-        )
-
-    def __str__(self) -> str:
-        return f"OptionsContract(expiration={self.expiration},put_or_call={self.put_or_call},strike={self.strike},ticker={self.ticker},underlying={self.underlying},in_the_money={self.in_the_money})"
-
-
-class OptionsGreeks(Struct, omit_defaults=True):
-    delta: Decimal
-    expiration: date
-    gamma: Decimal
-    implied_volatility: Decimal
-    put_or_call: PutOrCall
-    rho: Decimal
-    strike: Decimal
-    symbol: str
-    theta: Decimal
-    underlying: str
-    vega: Decimal
-
-    # Constructor that takes all field titles as arguments for convenience
-    @classmethod
-    def new(
-        cls,
-        delta: Decimal,
-        expiration: date,
-        gamma: Decimal,
-        implied_volatility: Decimal,
-        put_or_call: PutOrCall,
-        rho: Decimal,
-        strike: Decimal,
-        symbol: str,
-        theta: Decimal,
-        underlying: str,
-        vega: Decimal,
-    ):
-        return cls(
-            delta,
-            expiration,
-            gamma,
-            implied_volatility,
-            put_or_call,
-            rho,
-            strike,
-            symbol,
-            theta,
-            underlying,
-            vega,
-        )
-
-    def __str__(self) -> str:
-        return f"OptionsGreeks(delta={self.delta},expiration={self.expiration},gamma={self.gamma},implied_volatility={self.implied_volatility},put_or_call={self.put_or_call},rho={self.rho},strike={self.strike},symbol={self.symbol},theta={self.theta},underlying={self.underlying},vega={self.vega})"
-
-
 class OptionsSeriesInfo(Struct, omit_defaults=True):
     derivative_kind: DerivativeKind
     exercise_type: OptionsExerciseType

architect_py/grpc/orderflow.py

@@ -4,12 +4,8 @@ from typing import TYPE_CHECKING, Any, AsyncGenerator, AsyncIterator, Optional,
 
 import grpc.aio
 
-from architect_py.grpc.models.Orderflow.Orderflow import Orderflow
-from architect_py.grpc.models.Orderflow.OrderflowRequest import (
-    OrderflowRequest,
-    OrderflowRequest_route,
-    OrderflowRequestUnannotatedResponseType,
-)
+from architect_py.grpc.models.Orderflow.Orderflow import *
+from architect_py.grpc.models.Orderflow.OrderflowRequest import *
 
 if TYPE_CHECKING:
     from architect_py.async_client import AsyncClient
@@ -120,7 +116,7 @@ class OrderflowChannel:
         self, request_iterator: AsyncIterator[OrderflowRequest]
     ) -> AsyncGenerator[Orderflow, None]:
         """Low-level wrapper around Architect’s gRPC bidirectional stream."""
-        grpc_client = await self._client.core()
+        grpc_client = await self._client._core()
         decoder = grpc_client.get_decoder(OrderflowRequestUnannotatedResponseType)
 
         stub: grpc.aio.StreamStreamMultiCallable = grpc_client.channel.stream_stream(

architect_py/grpc/server.py

@@ -41,9 +41,7 @@ class OrderflowServicer(object):
 
 
 def add_OrderflowServicer_to_server(servicer, server):
-    decoder = msgspec.json.Decoder(
-        type=SubscribeOrderflowRequest.get_unannotated_response_type()
-    )
+    decoder = msgspec.json.Decoder(type=SubscribeOrderflowRequest)
     rpc_method_handlers = {
         "SubscribeOrderflow": grpc.unary_stream_rpc_method_handler(
             servicer.SubscribeOrderflow,

architect_py/tests/test_order_entry.py

@@ -4,7 +4,8 @@ from decimal import Decimal
 import pytest
 
 from architect_py import AsyncClient, OrderDir, TickRoundMethod
-from architect_py.grpc.models.definitions import OrderType
+from architect_py.common_types.tradable_product import TradableProduct
+from architect_py.grpc.models.definitions import OrderType, SpreaderParams
 
 
 @pytest.mark.asyncio
@@ -39,3 +40,121 @@ async def test_place_limit_order(async_client: AsyncClient):
     await async_client.cancel_order(order.id)
 
     await async_client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(3)
+async def test_place_market_order(async_client: AsyncClient):
+    venue = "CME"
+    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(front_future, venue)
+    assert snap is not None
+    assert snap.bid_price is not None
+    accounts = await async_client.list_accounts()
+    account = accounts[0]
+
+    # bid far below the best bid
+    order = await async_client.place_order(
+        symbol=front_future,
+        execution_venue=venue,
+        dir=OrderDir.BUY,
+        quantity=Decimal(1),
+        order_type=OrderType.MARKET,
+        account=str(account.account.id),
+    )
+
+    assert order is not None
+
+    await asyncio.sleep(1.5)
+    order = await async_client.get_order(order.id)
+    assert order is not None
+
+    await async_client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(3)
+async def test_equity_order(async_client: AsyncClient):
+    tradable_product = TradableProduct(base_or_value="AAPL US Equity/USD")
+
+    product_info = await async_client.get_product_info(tradable_product.base())
+    assert product_info is not None
+    venue = product_info.primary_venue
+    assert venue is not None
+
+    market_status = await async_client.get_market_status(tradable_product, venue)
+    if not market_status.is_trading:
+        pytest.skip(f"Market {venue} for {tradable_product} is not open")
+
+    info = await async_client.get_execution_info(tradable_product, venue)
+    assert info is not None
+    # assert info.tick_size is not None
+
+    tick_size = Decimal("0.01")
+
+    snap = await async_client.get_ticker(tradable_product, venue)
+    assert snap is not None
+    assert snap.bid_price is not None
+    accounts = await async_client.list_accounts()
+    account = accounts[0]
+
+    # bid far below the best bid
+    limit_price = TickRoundMethod.FLOOR(snap.bid_price * Decimal(0.9), tick_size)
+    order = await async_client.place_order(
+        symbol=tradable_product,
+        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)
+
+    await async_client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(3)
+async def test_spreader_algo(async_client: AsyncClient):
+    accounts = await async_client.list_accounts()
+    account = accounts[0]
+
+    venue = "CME"
+
+    front_ES_future = await async_client.get_front_future("ES CME Futures", venue)
+    front_NQ_future = await async_client.get_front_future("NQ CME Futures", venue)
+
+    params = SpreaderParams(
+        dir=OrderDir.BUY,  # or OrderDir.SELL
+        leg1_marketdata_venue=venue,
+        leg1_price_offset=Decimal("0"),
+        leg1_price_ratio=Decimal("1"),
+        leg1_quantity_ratio=Decimal("1"),
+        leg1_symbol=front_ES_future,
+        leg2_marketdata_venue=venue,
+        leg2_price_offset=Decimal("0"),
+        leg2_price_ratio=Decimal("-1"),
+        leg2_quantity_ratio=Decimal("-1"),
+        leg2_symbol=front_NQ_future,
+        limit_price=Decimal("0.25"),
+        order_lockout="1s",
+        quantity=Decimal("10"),
+        leg1_account=account.account.id,
+        leg1_execution_venue=venue,
+        leg2_account=account.account.id,
+        leg2_execution_venue=venue,
+    )
+
+    order = await async_client.place_algo_order(params=params)
+
+    print(order)
+
+    await async_client.close()

architect_py/tests/test_positions.py

@@ -3,32 +3,126 @@ from decimal import Decimal
 
 import pytest
 
-from architect_py.async_client import AsyncClient, OrderDir, OrderType
+from architect_py import AsyncClient, OrderDir, OrderType, TradableProduct
 
+ES_MULTIPLIER = Decimal("50.0")  # ES futures multiplier
 
-@pytest.mark.asyncio
-@pytest.mark.timeout(10)
-async def test_positions(async_client: AsyncClient):
-    if not async_client.paper_trading:
-        return
 
+@pytest.mark.asyncio
+async def test_paper_setup(async_client: AsyncClient):
     accounts = await async_client.list_accounts()
 
     assert len(accounts) == 1, (
         f"Expected exactly one account in paper trading mode, got {len(accounts)}"
     )
-    account_id = accounts[0].account.id
+
+    front_ES_future = await async_client.get_front_future("ES CME Futures", "CME")
+
+    product_info = await async_client.get_product_info(front_ES_future.base())
+    assert product_info is not None, (
+        f"Expected product info for {front_ES_future.base()} to be not None"
+    )
+    assert product_info.multiplier == ES_MULTIPLIER, (
+        f"Expected multiplier for {front_ES_future.base()} to be {ES_MULTIPLIER}, got {product_info.multiplier}"
+    )
+    await async_client.close()
+
+
+@pytest.mark.asyncio
+async def test_flattening_position(async_client: AsyncClient):
+    if not async_client.paper_trading:
+        return
+
     front_ES_future = await async_client.get_front_future("ES CME Futures", "CME")
+    [account] = await async_client.list_accounts()
+    account_id = account.account.id
+
+    market_status = await async_client.get_market_status(front_ES_future, "CME")
+    if not market_status.is_trading:
+        await async_client.close()
+        pytest.skip(
+            f"Market for {front_ES_future} is not trading, skipping test_flattening_position"
+        )
+
+    await async_client.place_order(
+        symbol=front_ES_future,
+        venue="CME",
+        dir=OrderDir.BUY,
+        quantity=Decimal(value="100"),
+        account=account_id,
+        order_type=OrderType.MARKET,
+    )
+
+    positions = await async_client.get_positions(accounts=[account_id])
+
+    for tp, position in positions.items():
+        tradable_product = TradableProduct(tp)
+        product_info = await async_client.get_product_info(tradable_product.base())
+        assert product_info is not None, (
+            f"Expected product info for {tradable_product.base()} to be not None"
+        )
+        venue = product_info.primary_venue
+        assert venue is not None, (
+            f"Expected primary venue for {tradable_product.base()} to be not None"
+        )
+
+        market_status = await async_client.get_market_status(
+            symbol=tp,
+            venue=venue,
+        )
+        if not market_status.is_trading:
+            continue
+
+        if position != Decimal(0):
+            flatten_direction = OrderDir.SELL if position > Decimal(0) else OrderDir.BUY
+
+            await async_client.place_order(
+                symbol=tp,
+                dir=flatten_direction,
+                quantity=abs(position),
+                account=account_id,
+                order_type=OrderType.MARKET,
+            )
+
+    await asyncio.sleep(1.5)  # wait for orders to be processed
+
+    positions = await async_client.get_positions(accounts=[account_id])
+    assert len(positions) == 0, (
+        f"Expected no positions in paper trading mode, got {len(positions)}"
+    )
+    await async_client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_paper_positions(async_client: AsyncClient):
+    venue = "CME"
+    if not async_client.paper_trading:
+        return
+
+    [account] = await async_client.list_accounts()
+    account_id = account.account.id
+    front_ES_future = await async_client.get_front_future("ES CME Futures", venue)
     positions = await async_client.get_positions(accounts=[account_id])
     ES_position = positions.get(front_ES_future)
 
+    market_status = await async_client.get_market_status(
+        symbol=front_ES_future,
+        venue=venue,
+    )
+    if not market_status.is_trading:
+        await async_client.close()
+        pytest.skip(
+            f"Market for {front_ES_future} is not trading, skipping test_paper_pnl"
+        )
+
     # flatten position
     if ES_position is not None:
         flatten_direction = OrderDir.SELL if ES_position > Decimal(0) else OrderDir.BUY
 
         order = await async_client.place_order(
             symbol=front_ES_future,
-            venue="CME",
+            venue=venue,
             dir=flatten_direction,
             quantity=Decimal(value="1"),
             account=account_id,
@@ -49,7 +143,7 @@ async def test_positions(async_client: AsyncClient):
     # go long
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.BUY,
         quantity=Decimal(value="5"),
         account=account_id,
@@ -63,7 +157,7 @@ async def test_positions(async_client: AsyncClient):
     # go long to flat
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.SELL,
         quantity=Decimal(value="5"),
         account=account_id,
@@ -77,7 +171,7 @@ async def test_positions(async_client: AsyncClient):
     # go long
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.BUY,
         quantity=Decimal(value="8"),
         account=account_id,
@@ -91,7 +185,7 @@ async def test_positions(async_client: AsyncClient):
     # go long to short
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.SELL,
         quantity=Decimal(value="10"),
         account=account_id,
@@ -105,7 +199,7 @@ async def test_positions(async_client: AsyncClient):
     # go flat
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.BUY,
         quantity=Decimal(value="2"),
         account=account_id,
@@ -119,7 +213,7 @@ async def test_positions(async_client: AsyncClient):
     # go short
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.SELL,
         quantity=Decimal(value="5"),
         account=account_id,
@@ -133,7 +227,7 @@ async def test_positions(async_client: AsyncClient):
     # go short to flat
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.BUY,
         quantity=Decimal(value="5"),
         account=account_id,
@@ -147,7 +241,7 @@ async def test_positions(async_client: AsyncClient):
     # go short
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.SELL,
         quantity=Decimal(value="5"),
         account=account_id,
@@ -161,7 +255,7 @@ async def test_positions(async_client: AsyncClient):
     # go short to long
     order = await async_client.place_order(
         symbol=front_ES_future,
-        venue="CME",
+        venue=venue,
         dir=OrderDir.BUY,
         quantity=Decimal(value="10"),
         account=account_id,
@@ -171,3 +265,100 @@ async def test_positions(async_client: AsyncClient):
     assert positions.get(front_ES_future) == Decimal(5), (
         f"Expected position in {front_ES_future} to be 5, got {positions.get(front_ES_future)}"
     )
+    await async_client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_paper_pnl(async_client: AsyncClient):
+    if not async_client.paper_trading:
+        return
+
+    [account] = await async_client.list_accounts()
+    account_id = account.account.id
+    front_ES_future = await async_client.get_front_future("ES CME Futures", "CME")
+    positions = await async_client.get_positions(accounts=[account_id])
+    ES_position = positions.get(front_ES_future)
+
+    market_status = await async_client.get_market_status(
+        symbol=front_ES_future,
+        venue="CME",
+    )
+    if not market_status.is_trading:
+        await async_client.close()
+        pytest.skip(
+            f"Market for {front_ES_future} is not trading, skipping test_paper_pnl"
+        )
+
+    # flatten position
+    if ES_position is not None:
+        flatten_direction = OrderDir.SELL if ES_position > Decimal(0) else OrderDir.BUY
+
+        quantity = abs(ES_position)
+
+        order = await async_client.place_order(
+            symbol=front_ES_future,
+            venue="CME",
+            dir=flatten_direction,
+            quantity=quantity,
+            account=account_id,
+            order_type=OrderType.MARKET,
+        )
+        while True:
+            open_orders = await async_client.get_open_orders(order_ids=[order.id])
+            if not open_orders:
+                break
+            await asyncio.sleep(0.2)
+
+    position = await async_client.get_positions(accounts=[account_id])
+    assert len(position) == 0, (
+        f"Expected no positions in paper trading mode, got {position}"
+    )
+
+    account_summary = await async_client.get_account_summary(account_id)
+    assert account_summary.purchasing_power is not None, (
+        "Expected purchasing power after trades to be set, got None"
+    )
+
+    pre_purchasing_power = account_summary.purchasing_power
+
+    quantity = Decimal(value="7")
+
+    sell_order = await async_client.place_order(
+        symbol=front_ES_future,
+        venue="CME",
+        dir=OrderDir.SELL,
+        quantity=quantity,
+        account=account_id,
+        order_type=OrderType.MARKET,
+    )
+
+    buy_order = await async_client.place_order(
+        symbol=front_ES_future,
+        venue="CME",
+        dir=OrderDir.BUY,
+        quantity=quantity,
+        account=account_id,
+        order_type=OrderType.MARKET,
+    )
+    await asyncio.sleep(1.5)  # wait for order to be processed
+
+    sell_fill = await async_client.get_fills(order_id=sell_order.id)
+    sell_fill_price = sell_fill.fills[0].price
+
+    buy_fill = await async_client.get_fills(order_id=buy_order.id)
+    buy_fill_price = buy_fill.fills[0].price
+
+    pnl = (sell_fill_price - buy_fill_price) * ES_MULTIPLIER * quantity
+
+    account_summary = await async_client.get_account_summary(account_id)
+    assert account_summary.purchasing_power is not None, (
+        "Expected purchasing power after trades to be set, got None"
+    )
+    post_purchasing_power = account_summary.purchasing_power
+
+    assert post_purchasing_power == pre_purchasing_power + pnl, (
+        f"Expected purchasing power to be {pre_purchasing_power + pnl}, got {post_purchasing_power}.\n"
+        f"Buy fill price: {buy_fill_price}, Sell fill price: {sell_fill_price}, quantity: {quantity}, pnl: {pnl}, pre_purchasing_power: {pre_purchasing_power}, post_purchasing_power: {post_purchasing_power}"
+    )
+    await async_client.close()

{architect_py-5.1.5.dist-info → architect_py-5.1.6.dist-info}/METADATA

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