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

architect_py/scalars.py

@@ -1,172 +0,0 @@
-from enum import Enum
-from typing import Literal, Optional
-
-from datetime import datetime, timezone
-
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from architect_py.graphql_client.base_model import UnsetType
-
-
-"""
-Custom Serialize / Deserializing functions for the scalars
-"""
-
-
-def serialize(value) -> str:
-    return value.serialize()
-
-
-class TradableProduct(str):
-    """
-    Example instantiations:
-        TradableProduct("ES 20250321 CME Future", "USD")
-        TradableProduct("ES 20250321 CME Future/USD")
-        (these are equivalent)
-
-    This type exists to enforce the
-    {base}/{quote} format for strings
-
-    A base is the product that is being priced in terms of the quote.
-    For example,
-    "ES 20250321 CME Future/USD" means that the ES 20250321 CME Future is priced in USD.
-    "ES 20250321 CME Future/EUR" means that the ES 20250321 CME Future is priced in EUR.
-    "ES 20250321 CME Future/BTC" means that the ES 20250321 CME Future is priced in BTC
-        (such a product does not exist on any exchange though).
-
-    For example in a currency pair, the base is the first currency and the quote is the second currency.
-    In the currency pair USD/EUR, USD is the base and EUR is the quote.
-    USD/EUR = 1.1234 means that 1 USD = 1.1234 EUR
-    EUR/USD = 0.8901 means that 1 EUR = 0.8901 USD
-    """
-
-    def __new__(
-        cls, base_or_value: str, quote: Optional[str] = None
-    ) -> "TradableProduct":
-        """
-        These are equivalent:
-            TradableProduct("ES 20250321 CME Future", "USD")
-            TradableProduct("ES 20250321 CME Future/USD")
-        """
-        if quote is None:
-            value = base_or_value
-        else:
-            value = f"{base_or_value}/{quote}"
-
-        assert (
-            "/" in value
-        ), f"TradableProduct must be in the form of 'base/quote'. Got: {base_or_value}"
-        return super().__new__(cls, value)
-
-    def base_quote(self) -> list[str]:
-        return self.split("/")
-
-    def base(self) -> str:
-        return self.split("/", 1)[0]
-
-    def quote(self) -> str:
-        return self.split("/", 1)[1]
-
-
-def parse_tradable_product(value: str) -> TradableProduct:
-    # for ariadne
-    return TradableProduct(value)
-
-
-class OrderDir(str, Enum):
-    BUY = "BUY"
-    SELL = "SELL"
-
-    def __int__(self):
-        if self == OrderDir.BUY:
-            return 1
-        elif self == OrderDir.SELL:
-            return -1
-        else:
-            raise ValueError(f"Unknown Dir: {self}")
-
-    def get_opposite(self) -> "OrderDir":
-        """
-        NOTE: ENUMS ARE IMMUTABLE SO THIS DOES NOT MUTATE THE STATE OF THE ENUM
-        """
-        if self == OrderDir.BUY:
-            return OrderDir.SELL
-        elif self == OrderDir.SELL:
-            return OrderDir.BUY
-        else:
-            raise ValueError(f"Unknown Dir: {self}")
-
-    def __str__(self) -> str:
-        return self.value
-
-    def lower(self) -> str:
-        return self.value.lower()
-
-    @classmethod
-    def from_string(cls, value: str) -> "OrderDir":
-        lower = value.lower()
-        if lower == "buy":
-            return cls.BUY
-        elif lower == "sell":
-            return cls.SELL
-        elif lower == "bid":
-            return cls.BUY
-        elif lower == "ask":
-            return cls.SELL
-        elif lower == "b":
-            return cls.BUY
-        elif lower == "a" or lower == "s":
-            return cls.SELL
-        else:
-            raise ValueError(f"Unknown Dir: {value}")
-
-    @classmethod
-    def from_unit(cls, value: Literal[1, -1]) -> "OrderDir":
-        if value == 1:
-            return cls.BUY
-        elif value == -1:
-            return cls.SELL
-        else:
-            raise ValueError(f"Unknown Dir: {value}")
-
-    @classmethod
-    def from_sign(cls, value: int) -> "OrderDir":
-        if value > 0:
-            return cls.BUY
-        elif value < 0:
-            return cls.SELL
-        else:
-            raise ValueError(f"Unknown Dir: {value}")
-
-
-def graphql_serialize_order_dir(value: OrderDir) -> str:
-    return value.lower()
-
-
-def graphql_parse_order_dir(value: str) -> OrderDir:
-    if value == "buy":
-        return OrderDir.BUY
-    else:
-        return OrderDir.SELL
-
-
-def convert_datetime_to_utc_str(dt: "Optional[datetime] | UnsetType") -> Optional[str]:
-    if not isinstance(dt, datetime):
-        return None
-
-    if dt.tzinfo is None:
-        raise ValueError(
-            "in a datetime sent to the backend, the good_til_date must be timezone-aware. Try \n"
-            "from zoneinfo import ZoneInfo\n"
-            "datetime(..., tzinfo={your_local_timezone}) or "
-            "datetime.now(tz=ZoneInfo('UTC'))\n"
-            "# examples of local timezones:\n"
-            "ZoneInfo('America/New_York'), "
-            "ZoneInfo('America/Los_Angeles'), ZoneInfo('America/Chicago')"
-        )
-    utc_str = dt.astimezone(timezone.utc).isoformat()[:-6]
-    # [:-6] removes the utc offset
-
-    return f"{utc_str}Z"

architect_py/tests/test_accounts.py

@@ -1,31 +0,0 @@
-from decimal import Decimal
-import pytest
-
-from architect_py.async_client import AsyncClient
-
-from collections import defaultdict
-
-
-@pytest.mark.asyncio
-async def test_account(async_client: AsyncClient):
-    return
-
-    accounts = await async_client.list_accounts()
-    assert accounts is not None
-    assert len(accounts) > 0
-
-    unaggregated_summary = await async_client.get_account_summary(
-        account=accounts[0].account.id
-    )
-
-    symbol_to_position = defaultdict(Decimal)
-    for symbol, positions in unaggregated_summary.positions.items():
-        for position in positions:
-            symbol_to_position[symbol] += position.quantity
-
-    aggregated_summary = await async_client.get_account_summary(
-        account=accounts[0].account.id
-    )
-
-    assert unaggregated_summary is not None
-    assert aggregated_summary is not None

architect_py/tests/test_client.py

@@ -1,29 +0,0 @@
-import pytest
-from architect_py.async_client import AsyncClient
-from architect_py.client import Client
-
-
-@pytest.mark.asyncio
-async def test_client_init():
-    with pytest.raises(ValueError):
-        client = AsyncClient(host="localhost", port=4567, api_key=" ", api_secret=" ")
-    with pytest.raises(ValueError):
-        client = AsyncClient(
-            host="localhost", port=4567, api_key="something", api_secret='"alskjdf"'
-        )
-
-
-@pytest.mark.asyncio
-async def test_client_jwt(async_client: AsyncClient):
-    jwt = await async_client.graphql_client.create_jwt()
-    assert jwt is not None, "jwt should not be None"
-
-
-def test_sync_client(sync_client: Client):
-    sync_result = sync_client.search_symbols(execution_venue="CME", search_string="ES")
-    assert len(sync_result) > 5
-
-    ES_future = sync_result[0]
-
-    sync_result = sync_client.search_symbols(ES_future)
-    assert sync_result is not None

architect_py/tests/test_grpc_client.py

@@ -1,30 +0,0 @@
-import pytest
-
-from architect_py.async_client import AsyncClient
-from architect_py.scalars import TradableProduct
-
-
-@pytest.mark.asyncio
-async def test_grpc(async_client: AsyncClient, front_ES_future: str):
-
-    endpoint = "binance.marketdata.architect.co"
-    endpoint = "bybit.marketdata.architect.co"
-    endpoint = "binance-futures-usd-m.marketdata.architect.co"
-    endpoint = "cme.marketdata.architect.co"
-
-    tp = TradableProduct(front_ES_future, "USD")
-    snapshot = await async_client.grpc_client.request_l2_book_snapshot("CME", tp)
-    assert snapshot is not None
-
-    snapshot = await async_client.grpc_client.request_l1_book_snapshot(tp)
-    assert snapshot is not None
-
-    i = 0
-    async for update in await async_client.grpc_client.subscribe_l1_books_stream(
-        [front_ES_future]
-    ):
-        assert update is not None
-        if i == 100:
-            break
-        i += 1
-    return True

architect_py/tests/test_order_sending.py

@@ -1,61 +0,0 @@
-from decimal import Decimal
-
-import pytest
-
-from architect_py.async_client import AsyncClient, OrderDir
-from architect_py.scalars import TradableProduct
-from architect_py.utils.nearest_tick_2 import TickRoundMethod
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(3)
-async def test_live_far_order_cancel(async_client: AsyncClient, front_ES_future: str):
-    """
-    Places a bid order far below best bid, waits for placement, then should successfully cancel order
-    """
-    venue = "CME"
-    tp = TradableProduct(front_ES_future, "USD")
-
-    # Get snapshot
-    execution_info = await async_client.get_execution_info(tp, venue)
-    assert (
-        execution_info is not None
-    ), f"execution_info does not exist for {tp}, {venue}"
-
-    assert execution_info.min_order_quantity is not None
-    assert execution_info.tick_size is not None
-
-    snapshot = await async_client.get_market_snapshot(tp, venue)
-    assert snapshot is not None, f"Snapshot does not exist for {tp} at venue {venue}"
-
-    min_qty = Decimal(execution_info.min_order_quantity)
-
-    if bid_price := snapshot.bid_price:
-        far_price = bid_price * Decimal("0.8")
-    else:
-        raise ValueError(f"No bid price in snapshot for {tp} at venue {venue}")
-    limit_price = TickRoundMethod.FLOOR(far_price, execution_info.tick_size)
-
-    accounts = await async_client.list_accounts()
-
-    account = accounts[0]
-    print(account)
-
-    # Make a very cheap bid
-    order = await async_client.send_limit_order(
-        symbol=tp,
-        odir=OrderDir.BUY,
-        execution_venue=venue,
-        quantity=min_qty,
-        limit_price=limit_price,
-        account=str(account.account.id),
-    )
-
-    assert order is not None
-
-    order_query = await async_client.get_order(order.id)
-    if order_query is None:
-        raise ValueError("Order is None")
-    else:
-        cancel = await async_client.cancel_order(order.id)
-        assert cancel

architect_py/tests/test_snapshots.py

@@ -1,52 +0,0 @@
-import pytest
-
-from architect_py.async_client import AsyncClient
-from architect_py.scalars import TradableProduct
-
-from pytest_lazy_fixtures import lf
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "symbol,venue",
-    [
-        (lf("front_ES_future"), "CME"),
-        # (
-        #     "BTC-USDT BINANCE Perpetual/USDT Crypto*BINANCE-FUTURES-USD-M/DIRECT",
-        #     "BINANCE",
-        # ),
-        # (
-        #     "BTC-USDT BYBIT Perpetual/USDT Crypto*BYBIT/DIRECT",
-        #     "BYBIT",
-        # ),
-    ],
-)
-async def test_l2_snapshot(async_client: AsyncClient, symbol: str, venue: str):
-    tp = TradableProduct(symbol, "USD")
-
-    market_status = await async_client.get_market_status(tp, venue)
-    if not market_status.is_trading:
-        pytest.skip("market is not trading")
-
-    snap = await async_client.get_l2_book_snapshot(
-        tp,
-        venue,
-    )
-    assert snap is not None, "snapshot should not be None"
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(3)
-async def test_marketdata_snapshots(async_client: AsyncClient, front_ES_future: str):
-    venue = "CME"
-
-    market = TradableProduct(front_ES_future, "USD")
-    market_status = await async_client.get_market_status(market, venue)
-
-    if not market_status.is_trading:
-        pytest.skip("market is not trading")
-
-    snap = await async_client.get_market_snapshot(
-        symbol=TradableProduct(market), venue="CME"
-    )
-    assert snap is not None, "snapshot should not be None"

architect_py/tests/test_subscriptions.py

@@ -1,129 +0,0 @@
-import asyncio
-from datetime import datetime
-import pytest
-from architect_py.async_client import AsyncClient
-from architect_py.scalars import TradableProduct
-
-from zoneinfo import ZoneInfo
-
-from pytest_lazy_fixtures import lf
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(10)
-@pytest.mark.parametrize(
-    "endpoint,symbol,venue",
-    [
-        ("cme.marketdata.architect.co", lf("front_ES_future_tp"), "CME"),
-        # (
-        #     "https://usdm.binance.marketdata.architect.co",
-        #     "BTC-USDT BINANCE Perpetual/USDT Crypto",
-        #     "BINANCE",
-        # ),
-        # (
-        #     "https://bybit.marketdata.architect.co",
-        #     "BTC-USDT BYBIT Perpetual/USDT Crypto",
-        #     "BYBIT",
-        # ),
-    ],
-)
-@pytest.mark.asyncio
-async def test_subscribe_l1_stream(
-    async_client: AsyncClient,
-    endpoint: str,
-    symbol: str,
-    venue: str,
-):
-    tp = TradableProduct(symbol)
-
-    await async_client.grpc_client.change_channel(endpoint)
-
-    market_status = await async_client.get_market_status(tp, venue)
-    if not market_status.is_trading:
-        pytest.skip("market is not trading")
-
-    symbols = [tp]
-
-    [l1_book] = await async_client.subscribe_l1_book(symbols)
-
-    i = 0
-    async for snap in async_client.subscribe_l1_book_stream(symbols, venue):
-        assert snap.best_bid is not None, f"{symbol} should always be bid"
-        assert snap.best_ask is not None, f"{symbol} should always be offered"
-        assert snap.best_bid[0] > 1_000, f"{symbol} should be > $1000"
-        assert snap.best_ask[0] < 10_000_000, f"{symbol} should be < $10000000"
-        i += 1
-        if i > 5:
-            break
-
-    if l1_book.timestamp == 0:
-        raise ValueError(f"Timestamp should be increasing {l1_book}")
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(10)
-@pytest.mark.parametrize(
-    "endpoint,symbol,venue",
-    [
-        ("cme.marketdata.architect.co", lf("front_ES_future_tp"), "CME"),
-        # (
-        #     "https://usdm.binance.marketdata.architect.co",
-        #     "BTC-USDT BINANCE Perpetual/USDT Crypto",
-        #     "BINANCE",
-        # ),
-        # (
-        #     "https://bybit.marketdata.architect.co",
-        #     "BTC-USDT BYBIT Perpetual/USDT Crypto",
-        #     "BYBIT",
-        # ),
-    ],
-)
-@pytest.mark.asyncio
-@pytest.mark.timeout(10)
-async def test_subscribe_l2_stream(
-    async_client: AsyncClient, endpoint: str, symbol: str, venue: str
-):
-    tp = TradableProduct(symbol)
-
-    market_status = await async_client.get_market_status(tp, venue)
-    if not market_status.is_trading:
-        pytest.skip("market is not trading")
-
-    l2_book = await async_client.subscribe_l2_book(tp, venue)
-    ts = l2_book.timestamp
-
-    i = 0
-    async for snap in async_client.grpc_client.subscribe_l2_books_stream(
-        symbol=tp, venue=venue
-    ):
-        assert snap is not None
-        if i > 5:
-            break
-        i += 1
-    await asyncio.sleep(1)
-
-    if ts >= l2_book.timestamp:
-        raise ValueError(f"Timestamp should be increasing {l2_book}")
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(15)
-async def test_subscribe_cme_trades(async_client: AsyncClient):
-    venue = "CME"
-    markets = await async_client.get_cme_futures_series("ES CME Futures")
-    _, market = markets[0]
-
-    market = TradableProduct(market, "USD")
-    market_status = await async_client.get_market_status(market, venue)
-
-    if not market_status.is_trading:
-        pytest.skip("market is not trading")
-    elif not 9 <= datetime.now(ZoneInfo("America/Chicago")).hour < 17:
-        pytest.skip("market is not liquid")
-
-    i = 0
-    async for trade in async_client.subscribe_trades_stream(market, venue):
-        assert trade is not None, "trade from stream was None"
-        if i > 3:
-            break
-        i += 1