architect-py 3.2.2__py3-none-any.whl → 5.0.0b2__py3-none-any.whl

architect_py/tests/test_orderflow.py

@@ -0,0 +1,41 @@
+"""
+import asyncio
+
+import pytest
+
+from architect_py.async_client import AsyncClient
+from architect_py.grpc.models.Orderflow.OrderflowRequest import OrderflowRequest
+
+
+class OrderflowAsyncIterator:
+    queue: list[OrderflowRequest]
+    condition: asyncio.Condition
+
+    def __init__(self):
+        self.queue: list[OrderflowRequest] = []
+        self.condition: asyncio.Condition = asyncio.Condition()
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self) -> OrderflowRequest:
+        async with self.condition:
+            while not self.queue:
+                await self.condition.wait()
+            return self.queue.pop(0)
+
+    async def add_to_queue(self, item: OrderflowRequest):
+        async with self.condition:
+            self.queue.append(item)
+            self.condition.notify()
+
+
+@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
+
+"""

architect_py/tests/test_portfolio_management.py

@@ -0,0 +1,23 @@
+import pytest
+
+from architect_py import AsyncClient
+
+
+@pytest.mark.asyncio
+async def test_list_accounts(async_client: AsyncClient):
+    accounts = await async_client.list_accounts()
+    assert accounts is not None
+    assert len(accounts) > 0
+
+
+@pytest.mark.asyncio
+async def test_get_account_summary(async_client: AsyncClient):
+    accounts = await async_client.list_accounts()
+    assert accounts is not None
+    assert len(accounts) > 0
+
+    summary = await async_client.get_account_summary(account=accounts[0].account.name)
+    assert summary is not None
+    assert summary.balances is not None
+    assert len(summary.balances) > 0
+    assert summary.positions is not None

architect_py/tests/test_rounding.py

@@ -1,41 +1,41 @@
-from decimal import Decimal
+# from decimal import Decimal
 
-from architect_py.utils.nearest_tick import TickRoundMethod
+# from architect_py.utils.nearest_tick import TickRoundMethod
 
 
-def test_rounding():
-    # Example usage
-    value = Decimal("123.454")
-    tick_size = Decimal("0.01")
+# def test_rounding():
+#     # Example usage
+#     value = Decimal("123.454")
+#     tick_size = Decimal("0.01")
 
-    rounded_value = TickRoundMethod.ROUND(value, tick_size=tick_size)
-    assert rounded_value == Decimal("123.45")
+#     rounded_value = TickRoundMethod.ROUND(value, tick_size=tick_size)
+#     assert rounded_value == Decimal("123.45")
 
-    rounded_ceil = TickRoundMethod.CEIL(value, tick_size)
-    assert rounded_ceil == Decimal("123.46")
+#     rounded_ceil = TickRoundMethod.CEIL(value, tick_size)
+#     assert rounded_ceil == Decimal("123.46")
 
-    rounded_floor = TickRoundMethod.FLOOR(value, tick_size)
-    assert rounded_floor == Decimal("123.45")
+#     rounded_floor = TickRoundMethod.FLOOR(value, tick_size)
+#     assert rounded_floor == Decimal("123.45")
 
-    rounded_floor = TickRoundMethod.FLOOR(Decimal("123.459"), tick_size)
-    assert rounded_floor == Decimal("123.45")
+#     rounded_floor = TickRoundMethod.FLOOR(Decimal("123.459"), tick_size)
+#     assert rounded_floor == Decimal("123.45")
 
-    rounded_toward_zero_pos = TickRoundMethod.TOWARD_ZERO(value, tick_size)
-    assert rounded_toward_zero_pos == Decimal("123.45")
+#     rounded_toward_zero_pos = TickRoundMethod.TOWARD_ZERO(value, tick_size)
+#     assert rounded_toward_zero_pos == Decimal("123.45")
 
-    value_negative = Decimal("-123.456")
-    rounded_toward_zero_neg = TickRoundMethod.TOWARD_ZERO(value_negative, tick_size)
-    assert rounded_toward_zero_neg == Decimal("-123.45")
+#     value_negative = Decimal("-123.456")
+#     rounded_toward_zero_neg = TickRoundMethod.TOWARD_ZERO(value_negative, tick_size)
+#     assert rounded_toward_zero_neg == Decimal("-123.45")
 
-    rounded_away_from_zero_pos = TickRoundMethod.AWAY_FROM_ZERO(value, tick_size)
-    assert rounded_away_from_zero_pos == Decimal("123.46")
+#     rounded_away_from_zero_pos = TickRoundMethod.AWAY_FROM_ZERO(value, tick_size)
+#     assert rounded_away_from_zero_pos == Decimal("123.46")
 
-    rounded_away_from_zero_neg = TickRoundMethod.AWAY_FROM_ZERO(
-        value_negative, tick_size
-    )
-    assert rounded_away_from_zero_neg == Decimal("-123.46")
+#     rounded_away_from_zero_neg = TickRoundMethod.AWAY_FROM_ZERO(
+#         value_negative, tick_size
+#     )
+#     assert rounded_away_from_zero_neg == Decimal("-123.46")
 
 
-if __name__ == "__main__":
-    test_rounding()
-    print("rounding.py: All tests passed!")
+# if __name__ == "__main__":
+#     test_rounding()
+#     print("rounding.py: All tests passed!")

architect_py/tests/test_symbology.py

@@ -2,32 +2,55 @@ import re
 from datetime import datetime
 
 import pytest
-from architect_py.async_client import AsyncClient
+
+from architect_py import AsyncClient
 
 
 @pytest.mark.asyncio
-async def test_futures_series_populated(async_client: AsyncClient):
-    # list of popular CME futures series and the minimum
-    # number of futures we expect to see per series
+async def test_list_symbols(async_client: AsyncClient):
+    symbols = await async_client.list_symbols()
+    assert len(symbols) > 0, "no symbols found"
+
+
+@pytest.mark.asyncio
+async def test_search_symbols_for_popular_CME_futures(async_client: AsyncClient):
+    """
+    Test that we have a minimum expected number of futures
+    for popular CME series.
+    """
     popular_series = [("ES", 5), ("GC", 5), ("NQ", 5)]
     for series, min_count in popular_series:
         markets = await async_client.search_symbols(
             execution_venue="CME", search_string=series
         )
         futures = [market for market in markets if market.startswith(f"{series} ")]
-        assert (
-            len(futures) > min_count
-        ), f"not enough futures markets found in {series} series: {len(markets)}"
+        assert len(futures) > min_count, (
+            f"not enough futures markets found in {series} series: {len(markets)}"
+        )
+
+
+@pytest.mark.asyncio
+async def test_cme_first_notice_date(async_client: AsyncClient):
+    # Find the nearest GC futures contract and check the first notice date
+    series_name = "GC CME Futures"
+    series = await async_client.get_futures_series(series_name)
+    assert len(series) > 0, "no futures markets found in GC series"
+
+    futures = await async_client.get_cme_futures_series(series_name)
+    exp_date, future = futures[0]
+    notice_date = await async_client.get_cme_first_notice_date(future)
+    assert notice_date is not None, "first notice date is None"
+    assert notice_date < exp_date, "first notice date is not before expiration"
 
 
 @pytest.mark.asyncio
-async def test_search_for_es_front_month(async_client: AsyncClient):
+async def test_get_cme_futures_series(async_client: AsyncClient):
     series = await async_client.get_cme_futures_series("ES CME Futures")
     assert len(series) > 0, "no futures markets found in ES series"
     _, front_month_future = series[0]
-    assert re.match(
-        r"ES \d* CME Future", front_month_future
-    ), "front month future base name does not match regex"
+    assert re.match(r"ES \d* CME Future", front_month_future), (
+        "front month future base name does not match regex"
+    )
 
 
 @pytest.mark.asyncio
@@ -35,16 +58,14 @@ async def test_get_cme_future_from_root_month_year(async_client: AsyncClient):
     # BTC futures are monthly.  To avoid end-of-month weekend expiration,
     # check the next month from the current date.
     now = add_one_month_to_datetime(datetime.now())
-
     month = now.month
     year = now.year
     future = await async_client.get_cme_future_from_root_month_year(
         "BTC", month=month, year=year
     )
-
-    assert re.match(
-        f"BTC {year}{month:02d}[0-9]{{2}} CME Future", future
-    ), "future base name does not match regex"
+    assert re.match(f"BTC {year}{month:02d}[0-9]{{2}} CME Future", future), (
+        "future base name does not match regex"
+    )
 
 
 def add_one_month_to_datetime(dt: datetime):
@@ -52,17 +73,3 @@ def add_one_month_to_datetime(dt: datetime):
         return dt.replace(year=dt.year + 1, month=1)
     else:
         return dt.replace(month=dt.month + 1)
-
-
-@pytest.mark.asyncio
-async def test_cme_first_notice_date(async_client: AsyncClient):
-    # Find the nearest GC futures contract and check the first notice date
-    series_name = "GC CME Futures"
-    series = await async_client.get_future_series(series_name)
-    assert len(series) > 0, "no futures markets found in GC series"
-
-    futures = await async_client.get_cme_futures_series(series_name)
-    exp_date, future = futures[0]
-    notice_date = await async_client.get_cme_first_notice_date(future)
-    assert notice_date is not None, "first notice date is None"
-    assert notice_date < exp_date, "first notice date is not before expiration"

architect_py/utils/nearest_tick.py

@@ -5,12 +5,10 @@ tick_size = get_tick_size(market_id, client)
 nearest_tick(123.456, TickRoundMethod.ROUND, tick_size)
 """
 
+import sys
 from enum import Enum
-
 from functools import partial
 
-import sys
-
 """
 This conditional import is to deal with
 FutureWarning: functools.partial will be a method descriptor in future Python versions; wrap it in enum.member() if you want to preserve the old behavior
@@ -19,14 +17,13 @@ given on Python 3.12+
 if sys.version_info >= (3, 11):
     from .nearest_tick_2 import *
 else:
-
     from decimal import (
-        Decimal,
         ROUND_CEILING,
         ROUND_DOWN,
         ROUND_FLOOR,
         ROUND_HALF_UP,
         ROUND_UP,
+        Decimal,
     )
 
     def round_method(value: Decimal, tick_size: Decimal) -> Decimal:

architect_py/utils/nearest_tick_2.py

@@ -8,14 +8,13 @@ nearest_tick(123.456, TickRoundMethod.ROUND, tick_size)
 """
 
 from decimal import (
-    Decimal,
     ROUND_CEILING,
     ROUND_DOWN,
     ROUND_FLOOR,
     ROUND_HALF_UP,
     ROUND_UP,
+    Decimal,
 )
-
 from enum import Enum, member
 
 

architect_py/utils/orderbook.py

@@ -0,0 +1,35 @@
+import bisect
+from decimal import Decimal
+
+
+def update_orderbook_side(
+    orderbook_side: list[list[Decimal]],
+    price: Decimal,
+    size: Decimal,
+    ascending: bool,
+) -> None:
+    """
+    Updates a sorted order list (either ascending for asks or descending for bids)
+    using binary search to insert, update, or remove the given price level.
+    """
+    if ascending:
+        idx = bisect.bisect_left(orderbook_side, [price, Decimal(0)])
+    else:
+        lo, hi = 0, len(orderbook_side)
+        while lo < hi:
+            mid = (lo + hi) // 2
+            if orderbook_side[mid][0] > price:
+                lo = mid + 1
+            else:
+                hi = mid
+        idx = lo
+
+    if idx < len(orderbook_side) and orderbook_side[idx][0] == price:
+        if size.is_zero():
+            orderbook_side.pop(idx)
+        else:
+            # Update the size.
+            orderbook_side[idx][1] = size
+    else:
+        if not size.is_zero():
+            orderbook_side.insert(idx, [price, size])

architect_py/utils/pandas.py

@@ -0,0 +1,44 @@
+from typing import List
+
+import msgspec
+import pandas as pd
+
+from ..grpc import Candle
+
+CANDLES_FIELD_MAP = {
+    "av": "sell_volume",
+    "bv": "buy_volume",
+    "s": "symbol",
+    "v": "volume",
+    "w": "width",
+    "ac": "ask_close",
+    "ah": "ask_high",
+    "al": "ask_low",
+    "ao": "ask_open",
+    "bc": "bid_close",
+    "bh": "bid_high",
+    "bl": "bid_low",
+    "bo": "bid_open",
+    "c": "close",
+    "h": "high",
+    "l": "low",
+    "mc": "mid_close",
+    "mh": "mid_high",
+    "ml": "mid_low",
+    "mo": "mid_open",
+    "o": "open",
+}
+
+
+def candles_to_dataframe(candles: List[Candle]) -> pd.DataFrame:
+    records = msgspec.to_builtins(candles)
+    df = pd.DataFrame.from_records(records)
+    df.rename(columns=CANDLES_FIELD_MAP, inplace=True)
+    df["timestamp"] = pd.to_datetime(
+        df["ts"] * 1_000_000_000 + df["tn"],
+        unit="ns",
+        utc=True,
+    )
+    df.style.hide(["tn", "ts"], axis=1)
+    df.set_index("timestamp", inplace=True)
+    return df

architect_py/utils/price_bands.py

@@ -73,7 +73,6 @@ price_band_pairs: dict[str, Decimal] = {
     "ZW": Decimal(0.0975),
     "XW": Decimal(0.0975),
     "CWD": Decimal(600),
-    "CWD": Decimal(300),
     "ZWT": Decimal(0.02),
     "KE": Decimal(0.0975),
     "KWD": Decimal(600),
@@ -384,7 +383,6 @@ price_band_pairs: dict[str, Decimal] = {
     "XUB": Decimal(0.2),
     "ACB": Decimal(0.2),
     "AEB": Decimal(0.2),
-    "FRC": Decimal(0.2),
     "TFB": Decimal(0.2),
     "USE": Decimal(0.2),
     "RBM": Decimal(2000),
@@ -481,7 +479,6 @@ price_band_pairs: dict[str, Decimal] = {
     "AUF": Decimal(0.001),
     "UV": Decimal(2),
     "AKR": Decimal(0.001),
-    "AKR": Decimal(0.001),
     "EFF": Decimal(0.001),
     "AUI": Decimal(2),
     "AGT": Decimal(0.01),

architect_py/utils/symbol_parsing.py

@@ -0,0 +1,29 @@
+"""
+Utility functions for decoding and understanding Architect symbols.
+"""
+
+from datetime import date, datetime
+from typing import Optional
+
+
+def nominative_expiration(symbol: str) -> Optional[date]:
+    """
+    For futures and options symbols, extract the expiration date.
+
+    Args:
+        symbol: e.g. "ES 20211217 CME Future" -> date(2021, 12, 17)
+
+    Returns:
+        The expiration date as a date object
+        None if the symbol is not a future or option
+
+    To get a more precise expiration time or certain rare situations
+    involving timezone skews, use get_product_info from AsyncClient
+    or Client instead, which looks up actual product facts from the
+    symbology service.
+    """
+    try:
+        _, d, *_ = symbol.split(" ")
+        return datetime.strptime(d, "%Y%m%d").date()
+    except ValueError:
+        return None

architect_py-5.0.0b2.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: architect-py
+Version: 5.0.0b2
+Summary: Python SDK for the Architect trading platform and brokerage.
+Author-email: "Architect Financial Technologies, Inc." <hello@architect.co>
+License-Expression: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncio>=3
+Requires-Dist: gql[httpx]<4,>=3.5.0
+Requires-Dist: grpcio>=1.66.1
+Requires-Dist: msgspec<0.20,>=0.19
+Requires-Dist: pandas>=2
+Requires-Dist: pydantic~=2.10
+Requires-Dist: websockets>=11
+Requires-Dist: dnspython>=2.0
+Dynamic: license-file
+
+# [![Architect](https://avatars.githubusercontent.com/u/116864654?s=29&v=2)](https://architect.co) architect_py 
+[![PyPI version](https://img.shields.io/pypi/v/architect-py.svg)](https://pypi.org/project/architect-py/)
+
+A fully-featured Python SDK for trading on [Architect](https://architect.co).
+
+Just some of the features of this SDK: symbology, portfolio management, order entry, advanced algos, and marketdata subscriptions.
+
+Also, it is compatible with Jupyter notebooks! Check the [examples for an example notebook](examples/jupyter_example.ipynb).
+
+## Installation
+
+- pip: `pip install architect-py`
+- poetry: `poetry add architect-py`
+- uv: `uv add architect-py`
+
+## API keys for the brokerage
+
+API keys/secrets for the brokerage can be generated on the [user account page](https://app.architect.co/user/account).
+
+
+## Example usage
+
+`AsyncClient` and `Client` are the entryways into making calls to the Architect backend.
+Note that the sync `Client` does not have access to any subscription functions, because they are async by nature.
+
+
+```python
+import asyncio
+
+from architect_py.async_client import AsyncClient
+from architect_py.scalars import TradableProduct
+
+async def main():
+    c = await AsyncClient.connect(
+        host="<your installation domain>",  # e.g. app.architect.co for the brokerage
+        api_key="<api key>",
+        api_secret="<api secret>"
+        paper_trading=True,
+    )
+    print(await c.who_am_i())
+
+    series = await async_client.get_cme_futures_series("ES CME Futures")
+    front_ES_future = series[0][1]
+
+    s = c.subscribe_trades_stream(front_ES_future)
+    async for trade in s:
+        print(trade)
+
+asyncio.run(main())
+```
+
+```python
+from architect_py.client import Client
+
+def main():
+    c = Client(
+        host="<your installation domain>",
+        api_key="<api key>",
+        api_secret="<api secret>"
+        paper_trading=True,
+    )
+    print(c.who_am_i())
+
+    print(client.get_account_summaries())
+
+    print(client.search_symbols("ES"))
+```
+
+While the AsyncClient is the recommended way to use the Architect API, the Client instead without any familiarity with `async/await`.
+The sync clients and async clients usage is identical, except one removes the `await` before the call. The only exception to this is that the sync client does not support any subscriptions, because they are inherently asynchronous.
+
+Check the `examples` folder or the `architect_py/tests` folders for example usages.
+
+
+## Method catalog 
+
+Check out the [FUNCTIONS.md](FUNCTIONS.md)  file to see a catalog of methods.
+
+---
+
+
+### Running examples from this package
+
+Clone this repository to run examples in the `examples` directory. This package
+uses poetry for dependency management. To enter a poetry virtual environment, make
+sure you have [poetry](https://python-poetry.org/docs/) installed and run the
+following from the repository root.
+
+```bash
+poetry shell
+poetry install --sync
+
+export ARCHITECT_HOST="<your installation domain>"
+export ARCHITECT_API_KEY="<api key>"
+export ARCHITECT_API_SECRET="<api secret>"
+
+python -m examples.trades
+```
+
+You can exit the poetry shell by running `exit`. Environment variables set
+within the shell are not persisted.