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

architect_py/grpc/resolve_endpoint.py

@@ -0,0 +1,70 @@
+import ipaddress
+import logging
+from typing import Tuple, cast
+from urllib.parse import urlparse
+
+import dns.asyncresolver
+import dns.resolver
+from dns.rdtypes.IN.SRV import SRV
+
+
+async def resolve_endpoint(endpoint: str) -> Tuple[str, int, bool]:
+    """
+    From a gRPC endpoint, resolve the host, port and whether or not the endpoint
+    should use SSL.  If the port is specified explicitly, it will be used.  Otherwise,
+    try to look up the port using the host's DNS SRV record.
+
+    If no SRV DNS record exists, or the hostname is an IP address, port will be None.
+
+    If the endpoint scheme is https, or the hostname matches *.architect.co,
+    return True for use_ssl.  Otherwise, return False.
+
+    Example outputs:
+
+    Assuming a SRV DNS record exists for app.architect.co pointing to port 8081.
+
+    | Endpoint | Host | Port | Use SSL |
+    |----------|------|------|---------|
+    | https://app.architect.co:8081 | app.architect.co | 8081 | True |
+    | http://app.architect.co:8081 | app.architect.co | 8081 | False |
+    | app.architect.co | app.architect.co | 8081 | True |
+    | localhost:9000 | localhost | 9000 | False |
+    """
+    if "://" not in endpoint:
+        endpoint = f"unknown://{endpoint}"
+    url = urlparse(endpoint)
+
+    if url.hostname is None:
+        raise ValueError(f"Invalid endpoint, missing hostname: {endpoint}")
+
+    use_ssl = url.scheme == "https" or (
+        url.scheme != "http" and url.hostname.endswith(".architect.co")
+    )
+
+    try:
+        _ = ipaddress.ip_address(url.hostname)
+        if url.port is None:
+            raise ValueError(
+                f"Invalid endpoint, target is an IP address but missing port: {endpoint}"
+            )
+        return url.hostname, url.port, url.scheme == "https"
+    except ValueError:
+        # not an IP address
+        pass
+
+    if url.port is not None:
+        return url.hostname, url.port, use_ssl
+
+    logging.info(f"No port specified for {endpoint}, looking up DNS SRV records...")
+    srv_records: dns.resolver.Answer = await dns.asyncresolver.resolve(
+        url.hostname, "SRV"
+    )
+    if len(srv_records) == 0:
+        raise Exception(f"No SRV records found for {url.hostname}")
+
+    record = cast(SRV, srv_records[0])
+    logging.info(f"Found {endpoint}: {record.target}:{record.port}")
+
+    host = str(record.target).rstrip(".")  # strips the period off of FQDNs
+
+    return host, record.port, use_ssl

architect_py/{grpc_client/grpc_server.py → grpc/server.py}

@@ -1,9 +1,14 @@
+"""
+Utility functions for hosting an Architect gRPC server;
+external cptys, python-based marketdata feeds, etc.
+"""
+
 import grpc
 import msgspec
-from typing import Union
-from .grpc_client import encoder
-from .Cpty.CptyRequest import Login, Logout, PlaceOrder, CancelOrder
-from .Orderflow.SubscribeOrderflowRequest import SubscribeOrderflowRequest
+
+from .models.Cpty.CptyRequest import UnannotatedCptyRequest
+from .models.Orderflow.SubscribeOrderflowRequest import SubscribeOrderflowRequest
+from .utils import encoder
 
 
 class CptyServicer(object):
@@ -14,8 +19,7 @@ class CptyServicer(object):
 
 
 def add_CptyServicer_to_server(servicer, server):
-    # CR alee: there must be a better way to get the unannotated request type
-    decoder = msgspec.json.Decoder(type=Union[Login, Logout, PlaceOrder, CancelOrder])
+    decoder = msgspec.json.Decoder(type=UnannotatedCptyRequest)
     rpc_method_handlers = {
         "Cpty": grpc.stream_stream_rpc_method_handler(
             servicer.Cpty,
@@ -37,9 +41,9 @@ class OrderflowServicer(object):
 
 
 def add_OrderflowServicer_to_server(servicer, server):
-    # CR alee: this doesn't work
-    # decoder = msgspec.json.Decoder(type=SubscribeOrderflowRequest.get_unannotated_response_type())
-    decoder = msgspec.json.Decoder(type=dict)
+    decoder = msgspec.json.Decoder(
+        type=SubscribeOrderflowRequest.get_unannotated_response_type()
+    )
     rpc_method_handlers = {
         "SubscribeOrderflow": grpc.unary_stream_rpc_method_handler(
             servicer.SubscribeOrderflow,

architect_py/grpc/utils.py

@@ -0,0 +1,32 @@
+from types import UnionType
+from typing import Any, Protocol, Type, TypeVar
+
+import msgspec
+
+from architect_py.common_types import TradableProduct
+
+
+def enc_hook(obj: Any) -> Any:
+    if isinstance(obj, TradableProduct):
+        return str(obj)
+
+
+encoder = msgspec.json.Encoder(enc_hook=enc_hook)
+decoders: dict[type | UnionType, msgspec.json.Decoder] = {}
+
+
+ResponseTypeGeneric = TypeVar("ResponseTypeGeneric", covariant=True)
+
+
+class RequestType(Protocol[ResponseTypeGeneric]):
+    @staticmethod
+    def get_unannotated_response_type() -> Type[ResponseTypeGeneric]: ...
+
+    @staticmethod
+    def get_response_type() -> Type[ResponseTypeGeneric]: ...
+
+    @staticmethod
+    def get_route() -> str: ...
+
+    @staticmethod
+    def get_rpc_method() -> Any: ...

architect_py/internal_utils/no_pandas.py

@@ -0,0 +1,3 @@
+from typing import Never
+
+DataFrame = Never

architect_py/tests/conftest.py

@@ -1,118 +1,124 @@
-from datetime import datetime
-import os
+"""
+Tests for architect-py can be run against any particular environment.
 
-import pytest
-import pytest_asyncio
-from architect_py.client import Client
-from architect_py.async_client import AsyncClient
-from dotenv import load_dotenv
+Set the following environments variables before running pytest:
 
-from architect_py.async_client import AsyncClient
+- ARCHITECT_ENDPOINT
+- ARCHITECT_API_KEY
+- ARCHITECT_API_SECRET
+- ARCHITECT_PAPER_TRADING
 
+Optional environment varaibles:
 
-"""
-if you have a file named ".env" in your working directory with:
+- ARCHITECT_GRAPHQL_PORT (default=4567)
+- DANGEROUS_ALLOW_LIVE_TRADING (default=False)
 
-ARCHITECT_API_KEY=your_key
-ARCHITECT_API_SECRET=your_secret
-PAPER_TRADING=False
+Environment variables may be set in a `.env` file.
 """
 
+import os
+from datetime import datetime, timedelta
 
-def is_truthy(value: str | None) -> bool:
-    return value is not None and value.lower() in ("1", "true", "yes")
+import pytest_asyncio
+from dotenv import load_dotenv
 
+from architect_py import AsyncClient
 
-@pytest_asyncio.fixture
-async def async_client() -> AsyncClient:
-    load_dotenv()
 
-    host = os.getenv("ARCHITECT_HOST") or "localhost"
-    port = os.getenv(key="ARCHITECT_PORT")
-    if port is not None:
-        port = int(port)
+def is_truthy(value: str | None) -> bool:
+    return value is not None and value.lower() in ("1", "true", "yes")
+
 
-    api_key = os.getenv("ARCHITECT_API_KEY")
-    api_secret = os.getenv("ARCHITECT_API_SECRET")
-    paper_trading = os.getenv("ARCHITECT_PAPER_TRADING")
-    if paper_trading is None:
-        paper_trading = True
-    else:
-        paper_trading = is_truthy(paper_trading)
+class TestEnvironment:
+    @classmethod
+    def from_env(cls):
+        endpoint = os.getenv("ARCHITECT_ENDPOINT")
+        api_key = os.getenv("ARCHITECT_API_KEY")
+        api_secret = os.getenv("ARCHITECT_API_SECRET")
 
-    dangerous_allow_app_architect_co = os.getenv("DANGEROUS_ALLOW_APP_ARCHITECT_CO")
+        assert endpoint is not None
+        assert api_key is not None
+        assert api_secret is not None
 
-    if host == "app.architect.co" and not is_truthy(dangerous_allow_app_architect_co):
-        raise ValueError(
-            "You have set the HOST to the production server. Please change it to the sandbox server."
+        paper_trading = is_truthy(os.getenv("ARCHITECT_PAPER_TRADING"))
+        dangerous_allow_live_trading = is_truthy(
+            os.getenv("DANGEROUS_ALLOW_LIVE_TRADING")
         )
-    if api_key is None or api_secret is None:
-        raise ValueError(
-            "You must set ARCHITECT_API_KEY and ARCHITECT_API_SECRET to run tests"
+        graphql_port = os.getenv("ARCHITECT_GRAPHQL_PORT")
+        if graphql_port is not None:
+            graphql_port = int(graphql_port)
+
+        if not paper_trading and not dangerous_allow_live_trading:
+            raise ValueError(
+                "You must set ARCHITECT_PAPER_TRADING=True or DANGEROUS_ALLOW_LIVE_TRADING=True to run live tests"
+            )
+
+        return cls(
+            endpoint=endpoint,
+            api_key=api_key,
+            api_secret=api_secret,
+            paper_trading=paper_trading,
+            graphql_port=graphql_port,
         )
 
-    return await AsyncClient.connect(
-        host=host,
-        _port=port,
-        api_key=api_key,
-        api_secret=api_secret,
-        paper_trading=paper_trading,
-    )
+    def __init__(
+        self,
+        *,
+        endpoint: str,
+        api_key: str,
+        api_secret: str,
+        paper_trading: bool,
+        graphql_port: int | None,
+    ):
+        self.endpoint = endpoint
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.paper_trading = paper_trading
+        self.graphql_port = graphql_port
 
 
-@pytest.fixture
-def sync_client():
+@pytest_asyncio.fixture
+async def async_client() -> AsyncClient:
     load_dotenv()
-    host = os.getenv("ARCHITECT_HOST") or "localhost"
-    port = os.getenv(key="ARCHITECT_PORT")
-    if port is not None:
-        port = int(port)
+    test_env = TestEnvironment.from_env()
+    async_client = await AsyncClient.connect(
+        api_key=test_env.api_key,
+        api_secret=test_env.api_secret,
+        paper_trading=test_env.paper_trading,
+        endpoint=test_env.endpoint,
+        graphql_port=test_env.graphql_port,
+    )
 
-    api_key = os.getenv("ARCHITECT_API_KEY")
-    api_secret = os.getenv("ARCHITECT_API_SECRET")
+    marketdata_endpoints = (("BINANCE/USDM", "usdm.binance.marketdata.architect.co"),)
+    for venue, endpoint in marketdata_endpoints:
+        await async_client.set_marketdata(venue, endpoint)
 
-    paper_trading = os.getenv("ARCHITECT_PAPER_TRADING")
-    if paper_trading is None:
-        paper_trading = True
-    else:
-        paper_trading = is_truthy(paper_trading)
+    return async_client
 
-    dangerous_allow_app_architect_co = os.getenv("DANGEROUS_ALLOW_APP_ARCHITECT_CO")
 
-    if host == "app.architect.co" and not is_truthy(dangerous_allow_app_architect_co):
-        raise ValueError(
-            "You have set the HOST to the production server. Please change it to the sandbox server."
-        )
-    if api_key is None or api_secret is None:
-        raise ValueError(
-            "You must set ARCHITECT_API_KEY and ARCHITECT_API_SECRET to run tests"
-        )
-    return Client(
-        host=host,
-        api_key=api_key,
-        api_secret=api_secret,
-        _port=port,
-        paper_trading=paper_trading,
-    )
+async def get_front_ES_future(async_client: AsyncClient) -> str:
+    series = await async_client.get_cme_futures_series("ES CME Futures")
+    series.sort()
+    today = datetime.now() + timedelta(days=30)
+    unexpired = list(filter(lambda item: item[0] > today.date(), series))
+    return unexpired[0][1]
 
 
 @pytest_asyncio.fixture
 async def front_ES_future(async_client: AsyncClient) -> str:
-    series = await async_client.get_cme_futures_series("ES CME Futures")
-
-    inc = 0
-    if datetime.now().date() >= async_client.get_expiration_from_CME_name(series[0][1]):
-        inc += 1
-
-    return series[inc][1]
+    """
+    Fixture for getting the name of the front month ES CME future.
+    """
+    return await get_front_ES_future(async_client)
 
 
 @pytest_asyncio.fixture
-async def front_ES_future_tp(async_client: AsyncClient) -> str:
-    series = await async_client.get_cme_futures_series("ES CME Futures")
+async def front_ES_future_usd(async_client: AsyncClient) -> str:
+    """
+    Fixture for getting the name of the front month ES CME future/USD pair.
+    """
+    future = await get_front_ES_future(async_client)
+    return f"{future}/USD"
 
-    inc = 0
-    if datetime.now().date() >= async_client.get_expiration_from_CME_name(series[0][1]):
-        inc += 1
 
-    return f"{series[inc][1]}/USD"
+# CR alee: add sync Client tests

architect_py/tests/test_book_building.py

@@ -1,56 +1,55 @@
-from decimal import Decimal
-import pytest
+# import pytest
+# from decimal import Decimal
+# from architect_py.grpc_client.Marketdata.L2BookUpdate import Diff, Snapshot
+# from architect_py.grpc_client.grpc_client import L2_update_from_diff
 
-from architect_py.grpc_client.Marketdata.L2BookUpdate import Diff, Snapshot
-from architect_py.grpc_client.grpc_client import L2_update_from_diff
 
+# @pytest.mark.asyncio
+# async def test_book_build():
+#     snapshot = Snapshot(
+#         a=[],
+#         b=[],
+#         sid=0,
+#         sn=0,
+#         ts=0,
+#         tn=0,
+#     )
 
-@pytest.mark.asyncio
-async def test_book_build():
-    snapshot = Snapshot(
-        a=[],
-        b=[],
-        sid=0,
-        sn=0,
-        ts=0,
-        tn=0,
-    )
+#     L2_update_from_diff(
+#         snapshot,
+#         Diff(
+#             a=[[Decimal(1), Decimal(1)]],
+#             b=[],
+#             sid=0,
+#             sn=0,
+#             ts=0,
+#             tn=0,
+#         ),
+#     )
 
-    L2_update_from_diff(
-        snapshot,
-        Diff(
-            a=[[Decimal(1), Decimal(1)]],
-            b=[],
-            sid=0,
-            sn=0,
-            ts=0,
-            tn=0,
-        ),
-    )
+#     assert snapshot == Snapshot(
+#         a=[[Decimal(1), Decimal(1)]],
+#         b=[],
+#         sid=0,
+#         sn=0,
+#         ts=0,
+#         tn=0,
+#     )
 
-    assert snapshot == Snapshot(
-        a=[[Decimal(1), Decimal(1)]],
-        b=[],
-        sid=0,
-        sn=0,
-        ts=0,
-        tn=0,
-    )
+#     snapshot = Snapshot(
+#         a=[[Decimal(3), Decimal(3)], [Decimal(4), Decimal(4)]],
+#         b=[[Decimal(1), Decimal(1)], [Decimal(2), Decimal(2)]],
+#         sid=0,
+#         sn=0,
+#         ts=0,
+#         tn=0,
+#     )
 
-    snapshot = Snapshot(
-        a=[[Decimal(3), Decimal(3)], [Decimal(4), Decimal(4)]],
-        b=[[Decimal(1), Decimal(1)], [Decimal(2), Decimal(2)]],
-        sid=0,
-        sn=0,
-        ts=0,
-        tn=0,
-    )
-
-    diff = Diff(
-        a=[[Decimal(3), Decimal(3)], [Decimal(4), Decimal(4)]],
-        b=[[Decimal(1), Decimal(1)], [Decimal(2), Decimal(2)]],
-        sid=0,
-        sn=0,
-        ts=0,
-        tn=0,
-    )
+#     diff = Diff(
+#         a=[[Decimal(3), Decimal(3)], [Decimal(4), Decimal(4)]],
+#         b=[[Decimal(1), Decimal(1)], [Decimal(2), Decimal(2)]],
+#         sid=0,
+#         sn=0,
+#         ts=0,
+#         tn=0,
+#     )

architect_py/tests/test_marketdata.py

@@ -0,0 +1,168 @@
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from pytest_lazy_fixtures import lf
+
+from architect_py import AsyncClient, CandleWidth
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_get_market_status(async_client: AsyncClient, venue: str, symbol: str):
+    market_status = await async_client.get_market_status(symbol, venue)
+    assert market_status is not None
+    # CR alee: this is broken upstream
+    # assert market_status.is_trading
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("CME", lf("front_ES_future_usd")),
+    ],
+)
+async def test_get_historical_candles(
+    async_client: AsyncClient, venue: str, symbol: str
+):
+    start = datetime.now(timezone.utc)
+    candles = await async_client.get_historical_candles(
+        symbol, venue, CandleWidth.OneHour, start - timedelta(hours=24), start
+    )
+    assert len(candles) > 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_get_l1_book_snapshot(async_client: AsyncClient, venue: str, symbol: str):
+    snap = await async_client.get_l1_book_snapshot(symbol, venue)
+    assert snap is not None
+    assert snap.best_bid is not None
+    assert snap.best_ask is not None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_get_l2_book_snapshot(async_client: AsyncClient, venue: str, symbol: str):
+    snap = await async_client.get_l2_book_snapshot(symbol, venue)
+    assert snap is not None
+    assert len(snap.bids) > 0
+    assert len(snap.asks) > 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_get_ticker(async_client: AsyncClient, venue: str, symbol: str):
+    ticker = await async_client.get_ticker(symbol, venue)
+    assert ticker is not None
+    assert ticker.last_price is not None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_stream_l1_book_snapshots(
+    async_client: AsyncClient, venue: str, symbol: str
+):
+    i = 0
+    async for snap in async_client.stream_l1_book_snapshots([symbol], venue):
+        assert snap is not None
+        assert snap.best_bid is not None
+        assert snap.best_ask is not None
+        i += 1
+        if i > 20:
+            break
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_stream_l2_book_updates(
+    async_client: AsyncClient, venue: str, symbol: str
+):
+    from architect_py.grpc.models.Marketdata.L2BookUpdate import Diff, Snapshot
+
+    i = 0
+    sid = None
+    sn = None
+    async for up in async_client.stream_l2_book_updates(symbol, venue):
+        assert up is not None
+        if isinstance(up, Snapshot):
+            assert len(up.bids) > 0
+            assert len(up.asks) > 0
+            assert i == 0, "snapshot should be the first update"
+            sid = up.sequence_id
+            sn = up.sequence_number
+        elif isinstance(up, Diff):
+            assert i > 0, "diff should not be the first update"
+            assert sid == up.sequence_id, "sequence number reset on diff"
+            assert sn is not None, "sequence number should be set"
+            assert up.sequence_number == sn + 1, (
+                "sequence number not monotonically increasing"
+            )
+            sn = up.sequence_number
+        i += 1
+        if i > 20:
+            break
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "venue,symbol",
+    [
+        ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+    ],
+)
+async def test_stream_trades(async_client: AsyncClient, venue: str, symbol: str):
+    i = 0
+    async for trade in async_client.stream_trades(symbol, venue):
+        assert trade is not None
+        i += 1
+        if i > 20:
+            break
+
+
+# @pytest.mark.asyncio
+# @pytest.mark.parametrize(
+#     "venue,symbol",
+#     [
+#         ("BINANCE/USDM", "BTC-USDT BINANCE Perpetual/USDT Crypto"),
+#     ],
+# )
+# async def test_stream_candles(async_client: AsyncClient, venue: str, symbol: str):
+#     i = 0
+#     async for candle in async_client.stream_candles(
+#         symbol, venue, [CandleWidth.OneSecond]
+#     ):
+#         assert candle is not None
+#         i += 1
+#         if i > 3:
+#             break

architect_py/tests/test_order_entry.py

@@ -0,0 +1,37 @@
+import asyncio
+from decimal import Decimal
+
+import pytest
+
+from architect_py import AsyncClient, OrderDir
+from architect_py.utils.nearest_tick_2 import TickRoundMethod
+
+
+@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)
+    assert info is not None
+    assert info.tick_size is not None
+    snap = await async_client.get_ticker(symbol, 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), info.tick_size)
+    order = await async_client.place_limit_order(
+        symbol=symbol,
+        execution_venue=venue,
+        odir=OrderDir.BUY,
+        quantity=Decimal(1),
+        limit_price=limit_price,
+        account=str(account.account.id),
+    )
+    assert order is not None
+    await asyncio.sleep(1)
+    await async_client.cancel_order(order.id)