architect-py 5.1.0b1__py3-none-any.whl → 5.1.2__py3-none-any.whl

architect_py/__init__.py

@@ -1,6 +1,6 @@
 # ruff: noqa:I001
 
-__version__ = "5.1.0b1"
+__version__ = "5.1.2"
 
 from .utils.nearest_tick import TickRoundMethod
 from .async_client import AsyncClient
@@ -13,6 +13,7 @@ from .grpc.models.definitions import (
     AlgoOrderStatus,
     CancelStatus,
     CandleWidth,
+    ConnectionStatus,
     CptyLogoutRequest,
     DateTimeOrUtc,
     Deposit,
@@ -269,6 +270,7 @@ __all__ = [
     "Commodity",
     "ConfigRequest",
     "ConfigResponse",
+    "ConnectionStatus",
     "CptyLoginRequest",
     "CptyLogoutRequest",
     "CptyRequest",

architect_py/async_client.py

@@ -43,7 +43,7 @@ from architect_py.grpc.models.Orderflow.OrderflowRequest import (
     OrderflowRequest_route,
     OrderflowRequestUnannotatedResponseType,
 )
-from architect_py.grpc.resolve_endpoint import resolve_endpoint
+from architect_py.grpc.resolve_endpoint import PAPER_GRPC_PORT, resolve_endpoint
 from architect_py.utils.nearest_tick import TickRoundMethod
 from architect_py.utils.orderbook import update_orderbook_side
 from architect_py.utils.pandas import candles_to_dataframe
@@ -102,7 +102,9 @@ class AsyncClient:
             )
             endpoint = kwargs["endpoint"]
 
-        grpc_host, grpc_port, use_ssl = await resolve_endpoint(endpoint)
+        grpc_host, grpc_port, use_ssl = await resolve_endpoint(
+            endpoint, paper_trading=paper_trading
+        )
         logging.info(
             f"Resolved endpoint {endpoint}: {grpc_host}:{grpc_port} use_ssl={use_ssl}"
         )
@@ -110,7 +112,7 @@ class AsyncClient:
         # Sanity check paper trading on prod environments
         if paper_trading:
             if grpc_host == "app.architect.co" or grpc_host == "staging.architect.co":
-                if grpc_port != 10081:
+                if grpc_port != PAPER_GRPC_PORT:
                     raise ValueError("Wrong gRPC port for paper trading")
                 if graphql_port is not None and graphql_port != 5678:
                     raise ValueError("Wrong GraphQL port for paper trading")
@@ -179,6 +181,29 @@ class AsyncClient:
         )
         self.grpc_core = GrpcClient(host=grpc_host, port=grpc_port, use_ssl=use_ssl)
 
+    async def close(self):
+        """
+        Close the gRPC channel and GraphQL client.
+
+        This fixes the:
+        Error in sys.excepthook:
+
+        Original exception was:
+
+        One might get when closing the client
+        """
+        if self.grpc_core is not None:
+            await self.grpc_core.close()
+
+        for grpc_client in self.grpc_marketdata.values():
+            await grpc_client.close()
+
+        self.grpc_marketdata.clear()
+        # NB: this line removes the "Error in sys.excepthook:" on close
+
+        if self.graphql_client is not None:
+            await self.graphql_client.close()
+
     async def refresh_jwt(self, force: bool = False):
         """
         Refresh the JWT for the gRPC channel if it's nearing expiration (within 1 minute).
@@ -259,6 +284,9 @@ class AsyncClient:
             self.grpc_marketdata[venue] = GrpcClient(
                 host=grpc_host, port=grpc_port, use_ssl=use_ssl
             )
+            logging.debug(
+                f"Setting marketdata endpoint for {venue}: {grpc_host}:{grpc_port} use_ssl={use_ssl}"
+            )
         except Exception as e:
             logging.error("Failed to set marketdata endpoint: %s", e)
 
@@ -503,34 +531,51 @@ class AsyncClient:
         if not series_symbol.endswith("Futures"):
             raise ValueError("series_symbol must end with 'Futures'")
         res = await self.graphql_client.get_future_series_query(series_symbol)
-        return res.futures_series
+
+        today = date.today()
+
+        futures = [
+            future
+            for future in res.futures_series
+            if (exp := nominative_expiration(future)) is not None and exp > today
+        ]
+        futures.sort()
+
+        return futures
 
     async def get_front_future(
-        self, series_symbol: str, venue: str, by_volume: bool = True
-    ) -> str:
+        self, series_symbol: str, venue: Optional[str] = None
+    ) -> TradableProduct:
         """
-        Gets the future with the most volume in a series.
+        Gets the front future.
+        ** If the venue is provided, it will return the future with the most volume in that venue**
+        Otherwise, will sort by expiration date and return the earliest future.
+
+        ** Note that this function returns a TradableProduct (ie with a base and a quote)
+
 
         Args:
             series_symbol: the futures series
                 e.g. "ES CME Futures" would yield the lead future for the ES series
             venue: the venue to get the lead future for, e.g. "CME"
-            by_volume: if True, sort by volume; otherwise sort by expiration date
+                ** If the venue is provided, it will return the future with the most volume in that venue**
 
         Returns:
             The lead future symbol
         """
         futures = await self.get_futures_series(series_symbol)
-        if not by_volume:
+        if not venue:
             futures.sort()
-            return futures[0]
+            return TradableProduct(futures[0], "USD")
         else:
             grpc_client = await self.marketdata(venue)
             req = TickersRequest(
-                symbols=futures, k=SortTickersBy.VOLUME_DESC, venue=venue
+                symbols=[TradableProduct(f"{future}/USD") for future in futures],
+                k=SortTickersBy.VOLUME_DESC,
+                venue=venue,
             )
             res: TickersResponse = await grpc_client.unary_unary(req)
-            return res.tickers[0].symbol
+            return TradableProduct(res.tickers[0].symbol)
 
     @staticmethod
     def get_expiration_from_CME_name(name: str) -> Optional[date]:
@@ -1337,8 +1382,7 @@ class AsyncClient:
 
         Example:
             ```python
-            request = SubscribeOrderflowRequest.new()
-            async for of in client.subscribe_orderflow_stream(request):
+            async for of in client.stream_orderflow(account, execution_venue, trader):
                 print(of)
             ```
         """
@@ -1375,6 +1419,48 @@ class AsyncClient:
         """
         return await self.place_limit_order(*args, **kwargs)
 
+    async def place_orders(
+        self, order_requests: Sequence[PlaceOrderRequest]
+    ) -> list[Order]:
+        """
+        A low level function to place multiple orders in a single function.
+
+        This function does NOT check the validity of the parameters, so it is the user's responsibility
+        to ensure that the orders are valid and will not be rejected by the OMS.
+
+        Args:
+            order_request: the PlaceOrderRequest containing the orders to place
+
+
+        Example of a PlaceOrderRequest:
+            order_request: PlaceOrderRequest = PlaceOrderRequest.new(
+                dir=dir,
+                quantity=quantity,
+                symbol=symbol,
+                time_in_force=time_in_force,
+                limit_price=limit_price,
+                order_type=order_type,
+                account=account,
+                id=id,
+                parent_id=None,
+                source=OrderSource.API,
+                trader=trader,
+                execution_venue=execution_venue,
+                post_only=post_only,
+                trigger_price=trigger_price,
+            )
+        """
+        grpc_client = await self.core()
+
+        res = await asyncio.gather(
+            *[
+                grpc_client.unary_unary(order_request)
+                for order_request in order_requests
+            ]
+        )
+
+        return res
+
     async def place_limit_order(
         self,
         *,
@@ -1448,7 +1534,7 @@ class AsyncClient:
             )
             if execution_info is None:
                 raise ValueError(
-                    "Could not find execution information for {symbol} for rounding price for limit order. Please round price manually."
+                    f"Could not find execution information for {symbol} for rounding price for limit order. Please round price manually."
                 )
             if (tick_size := execution_info.tick_size) is not None:
                 if tick_size:
@@ -1481,7 +1567,7 @@ class AsyncClient:
         id: Optional[OrderId] = None,
         symbol: TradableProduct | str,
         execution_venue: str,
-        odir: OrderDir,
+        dir: OrderDir,
         quantity: Decimal,
         time_in_force: TimeInForce = TimeInForce.DAY,
         account: Optional[str] = None,
@@ -1495,7 +1581,7 @@ class AsyncClient:
             id: in case user wants to generate their own order id, otherwise it will be generated automatically
             symbol: the symbol to send the order for
             execution_venue: the execution venue to send the order to
-            odir: the direction of the order
+            dir: the direction of the order
             quantity: the quantity of the order
             time_in_force: the time in force of the order
             account: the account to send the order for
@@ -1516,7 +1602,7 @@ class AsyncClient:
 
         price_band = price_band_pairs.get(symbol, None)
 
-        if odir == OrderDir.BUY:
+        if dir == OrderDir.BUY:
             if ticker.ask_price is None:
                 raise ValueError(
                     f"Failed to send market order with reason: no ask price for {symbol}"
@@ -1539,7 +1625,7 @@ class AsyncClient:
 
         # Conservatively round price to nearest tick
         tick_round_method = (
-            TickRoundMethod.FLOOR if odir == OrderDir.BUY else TickRoundMethod.CEIL
+            TickRoundMethod.FLOOR if dir == OrderDir.BUY else TickRoundMethod.CEIL
         )
 
         execution_info = await self.get_execution_info(
@@ -1556,7 +1642,7 @@ class AsyncClient:
             id=id,
             symbol=symbol,
             execution_venue=execution_venue,
-            odir=odir,
+            dir=dir,
             quantity=quantity,
             account=account,
             order_type=OrderType.LIMIT,
@@ -1605,11 +1691,13 @@ class AsyncClient:
             if cancel.reject_reason is not None:
                 return False
         return True
-        grpc_client = await self.core()
-        req = CancelAllOrdersRequest(
-            account=account,
-            execution_venue=execution_venue,
-            trader=trader,
-        )
-        res = await grpc_client.unary_unary(req)
-        return res
+        # grpc_client = await self.core()
+
+        # req = CancelAllOrdersRequest(
+        #     id=str(uuid.uuid4()),  # Unique ID for the request
+        #     account=account,
+        #     execution_venue=execution_venue,
+        #     trader=trader,
+        # )
+        # res = await grpc_client.unary_unary(req)
+        # return True

architect_py/client.py

@@ -2,13 +2,12 @@ import asyncio
 import sys
 import threading
 from asyncio import AbstractEventLoop
+from collections.abc import Callable
 from functools import partial
-from typing import Any, Awaitable, Callable, Coroutine, Optional, TypeVar
+from typing import Any, Concatenate, Coroutine, Optional, ParamSpec, TypeVar
 
 from .async_client import AsyncClient
 
-T = TypeVar("T")
-
 
 def is_async_function(obj):
     # can be converted to C function for faster performance
@@ -16,24 +15,30 @@ def is_async_function(obj):
     return callable(obj) and hasattr(obj, "__code__") and obj.__code__.co_flags & 0x80
 
 
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
 class Client:
     """
+    One can find the function definition in the AsyncClient class and in the pyi file.
+
     This class is a wrapper around the AsyncClient class that allows you to call async methods synchronously.
     This does not work for subscription based methods.
 
     This Client takes control of the event loop, which you can pass in.
 
-    One can find the function definition in the AsyncClient class.
 
     The AsyncClient is more performant and powerful, so it is recommended to use that class if possible.
-
-    Avoid adding functions or other attributes to this class unless you know what you are doing, because
-    the __getattribute__ method changes the behavior of the class in a way that is not intuitive.
-
-    Instead, add them to the AsyncClient class.
+    Avoid adding functions or other attributes to this class unless you know what you are doing.
     """
 
-    __slots__ = ("client", "_event_loop")
+    __slots__ = (
+        "client",
+        "_event_loop",
+        "_sync_call",
+        "__dict__",
+    )
     client: AsyncClient
     _event_loop: AbstractEventLoop
 
@@ -56,88 +61,69 @@ class Client:
         Pass in an `event_loop` if you want to use your own; otherwise, this class
         will use the default asyncio event loop.
         """
+        self._sync_call = self._pick_executor()
+
         if event_loop is None:
             try:
                 event_loop = asyncio.get_running_loop()
             except RuntimeError:
                 event_loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(event_loop)
-        super().__setattr__("_event_loop", event_loop)
-
-        async_client = self._event_loop.run_until_complete(
-            AsyncClient.connect(
-                api_key=api_key,
-                api_secret=api_secret,
-                paper_trading=paper_trading,
-                endpoint=endpoint,
-                graphql_port=graphql_port,
-                **kwargs,
-            )
+        object.__setattr__(self, "_event_loop", event_loop)
+
+        async_client: AsyncClient = self._sync_call(
+            AsyncClient.connect,
+            api_key=api_key,
+            api_secret=api_secret,
+            paper_trading=paper_trading,
+            endpoint=endpoint,
+            graphql_port=graphql_port,
+            **kwargs,
         )
-        super().__setattr__(
+
+        object.__setattr__(
+            self,
             "client",
             async_client,
         )
+        self._promote_async_client_methods()
 
+    def _pick_executor(
+        self,
+    ) -> Callable[
+        Concatenate[Callable[P, Coroutine[Any, Any, T]], P],
+        T,
+    ]:
+        """Return a function that runs a coroutine and blocks."""
         if "ipykernel" in sys.modules:
-            # for jupyter notebooks
+            executor = AsyncExecutor()
             import atexit
 
-            executor = AsyncExecutor()
             atexit.register(executor.shutdown)
+            return lambda fn, *a, **kw: executor.submit(fn(*a, **kw))
 
-            def _sync_call_create_task(
-                async_method: Callable[..., Coroutine[Any, Any, T]],
-                *args,
-                **kwargs,
-            ) -> T:
-                """
-                Executes the given coroutine synchronously using the executor.
-                """
-                return executor.submit(async_method(*args, **kwargs))
+        return lambda fn, *a, **kw: self._event_loop.run_until_complete(fn(*a, **kw))
 
-            super().__setattr__("_sync_call", _sync_call_create_task)
+    def _promote_async_client_methods(self) -> None:
+        for name in dir(self.client):
+            if name.startswith("_"):
+                continue
 
-    def __getattribute__(self, name: str):
-        """
-        You may have been lead here looking for the definition of a method of the Client
-        It can be found if you look in the AsyncClient class, which this class is a wrapper for,
-        or GraphQLClient, which is a parent class of AsyncClient
+            if any(x in name for x in ("stream", "subscribe", "connect")):
+                continue
+            attr = getattr(self.client, name)
 
-        Explanation:
-        __getattribute__ is a magic method that is called when searching for any attribute
-        In this case, will look through self.client, which is an instance of the Client class
+            if is_async_function(attr):
+                attr = partial(self._sync_call, attr)
 
-        We do this because we want to be able to call the async methods of the Client in a synchronous way,
-        but otherwise pass through the other attributes normally
+            object.__setattr__(self, name, attr)
 
-        It must be getattribute and not getattr because of the AsyncClientProtocol class inheritance
-        We gain type hinting but lose the ability to call the methods of the Client class itself
-        in a normal way
-        """
-        attr = getattr(super().__getattribute__("client"), name)
-        if is_async_function(attr):
-            if "subscribe" in name:
-                raise AttributeError(
-                    f"Method {name} is an subscription based async method and cannot be called synchronously"
-                )
-            return partial(super().__getattribute__("_sync_call"), attr)
+    def __setattr__(self, name: str, value: Any) -> None:
+        # protect wrapper internals
+        if name in ("client", "_event_loop", "_sync_call"):
+            object.__setattr__(self, name, value)
         else:
-            return attr
-
-    def __setattr__(self, name: str, value: Any):
-        """primarily to prevent unintended shadowing"""
-        client = super().__getattribute__("client")
-        setattr(client, name, value)
-
-    def _sync_call(
-        self, async_method: Callable[..., Awaitable[T]], *args, **kwargs
-    ) -> T:
-        return (
-            super()
-            .__getattribute__("_event_loop")
-            .run_until_complete(async_method(*args, **kwargs))
-        )
+            setattr(self.client, name, value)
 
 
 class AsyncExecutor:

architect_py/client.pyi

@@ -11,7 +11,7 @@ from architect_py.graphql_client.fragments import ExecutionInfoFields as Executi
 from architect_py.grpc.client import GrpcClient as GrpcClient
 from architect_py.grpc.models.Orderflow.OrderflowRequest import OrderflowRequestUnannotatedResponseType as OrderflowRequestUnannotatedResponseType, OrderflowRequest_route as OrderflowRequest_route
 from architect_py.grpc.models.definitions import AccountIdOrName as AccountIdOrName, AccountWithPermissions as AccountWithPermissions, CandleWidth as CandleWidth, L2BookDiff as L2BookDiff, OrderId as OrderId, OrderSource as OrderSource, OrderType as OrderType, SortTickersBy as SortTickersBy, TraderIdOrEmail as TraderIdOrEmail
-from architect_py.grpc.resolve_endpoint import resolve_endpoint as resolve_endpoint
+from architect_py.grpc.resolve_endpoint import PAPER_GRPC_PORT as PAPER_GRPC_PORT, resolve_endpoint as resolve_endpoint
 from architect_py.utils.nearest_tick import TickRoundMethod as TickRoundMethod
 from architect_py.utils.orderbook import update_orderbook_side as update_orderbook_side
 from architect_py.utils.pandas import candles_to_dataframe as candles_to_dataframe
@@ -23,19 +23,16 @@ from typing import Any, AsyncGenerator, AsyncIterator, Literal, Sequence, overlo
 
 class Client:
     """
+    One can find the function definition in the AsyncClient class and in the pyi file.
+
     This class is a wrapper around the AsyncClient class that allows you to call async methods synchronously.
     This does not work for subscription based methods.
 
     This Client takes control of the event loop, which you can pass in.
 
-    One can find the function definition in the AsyncClient class.
 
     The AsyncClient is more performant and powerful, so it is recommended to use that class if possible.
-
-    Avoid adding functions or other attributes to this class unless you know what you are doing, because
-    the __getattribute__ method changes the behavior of the class in a way that is not intuitive.
-
-    Instead, add them to the AsyncClient class.
+    Avoid adding functions or other attributes to this class unless you know what you are doing.
     """
     api_key: str | None
     api_secret: str | None
@@ -57,6 +54,17 @@ class Client:
         will use the default asyncio event loop.
         """
     l2_books: dict[Venue, dict[TradableProduct, tuple[L2BookSnapshot, asyncio.Task]]]
+    def close(self) -> None:
+        """
+        Close the gRPC channel and GraphQL client.
+
+        This fixes the:
+        Error in sys.excepthook:
+
+        Original exception was:
+
+        One might get when closing the client
+        """
     def refresh_jwt(self, force: bool = False):
         """
         Refresh the JWT for the gRPC channel if it's nearing expiration (within 1 minute).
@@ -209,15 +217,20 @@ class Client:
         Returns:
             List of futures products
         '''
-    def get_front_future(self, series_symbol: str, venue: str, by_volume: bool = True) -> str:
+    def get_front_future(self, series_symbol: str, venue: str | None = None) -> TradableProduct:
         '''
-        Gets the future with the most volume in a series.
+        Gets the front future.
+        ** If the venue is provided, it will return the future with the most volume in that venue**
+        Otherwise, will sort by expiration date and return the earliest future.
+
+        ** Note that this function returns a TradableProduct (ie with a base and a quote)
+
 
         Args:
             series_symbol: the futures series
                 e.g. "ES CME Futures" would yield the lead future for the ES series
             venue: the venue to get the lead future for, e.g. "CME"
-            by_volume: if True, sort by volume; otherwise sort by expiration date
+                ** If the venue is provided, it will return the future with the most volume in that venue**
 
         Returns:
             The lead future symbol
@@ -435,6 +448,35 @@ class Client:
         '''
         @deprecated(reason="Use place_limit_order instead")
         '''
+    def place_orders(self, order_requests: Sequence[PlaceOrderRequest]) -> list[Order]:
+        """
+        A low level function to place multiple orders in a single function.
+
+        This function does NOT check the validity of the parameters, so it is the user's responsibility
+        to ensure that the orders are valid and will not be rejected by the OMS.
+
+        Args:
+            order_request: the PlaceOrderRequest containing the orders to place
+
+
+        Example of a PlaceOrderRequest:
+            order_request: PlaceOrderRequest = PlaceOrderRequest.new(
+                dir=dir,
+                quantity=quantity,
+                symbol=symbol,
+                time_in_force=time_in_force,
+                limit_price=limit_price,
+                order_type=order_type,
+                account=account,
+                id=id,
+                parent_id=None,
+                source=OrderSource.API,
+                trader=trader,
+                execution_venue=execution_venue,
+                post_only=post_only,
+                trigger_price=trigger_price,
+            )
+        """
     def place_limit_order(self, *, id: OrderId | None = None, symbol: TradableProduct | str, execution_venue: str | None = None, dir: OrderDir | None = None, quantity: Decimal, limit_price: Decimal, order_type: OrderType = ..., time_in_force: TimeInForce = ..., price_round_method: TickRoundMethod | None = None, account: str | None = None, trader: str | None = None, post_only: bool = False, trigger_price: Decimal | None = None, **kwargs: Any) -> Order:
         '''
         Sends a regular limit order.
@@ -464,7 +506,7 @@ class Client:
 
             If the order is rejected, the order.reject_reason and order.reject_message will be set
         '''
-    def send_market_pro_order(self, *, id: OrderId | None = None, symbol: TradableProduct | str, execution_venue: str, odir: OrderDir, quantity: Decimal, time_in_force: TimeInForce = ..., account: str | None = None, fraction_through_market: Decimal = ...) -> Order:
+    def send_market_pro_order(self, *, id: OrderId | None = None, symbol: TradableProduct | str, execution_venue: str, dir: OrderDir, quantity: Decimal, time_in_force: TimeInForce = ..., account: str | None = None, fraction_through_market: Decimal = ...) -> Order:
         '''
         Sends a market-order like limit price based on the BBO.
         Meant to behave as a market order but with more protections.
@@ -473,7 +515,7 @@ class Client:
             id: in case user wants to generate their own order id, otherwise it will be generated automatically
             symbol: the symbol to send the order for
             execution_venue: the execution venue to send the order to
-            odir: the direction of the order
+            dir: the direction of the order
             quantity: the quantity of the order
             time_in_force: the time in force of the order
             account: the account to send the order for

architect_py/common_types/time_in_force.py

@@ -65,6 +65,7 @@ class TimeInForce:
 
     @classmethod
     def GTD(cls, when: datetime) -> "TimeInForce":
+        assert when.tzinfo is not None, "GTD requires a timezone-aware datetime"
         return cls("GTD", when)
 
     def serialize(self) -> msgspec.Raw:

architect_py/common_types/tradable_product.py

@@ -54,7 +54,7 @@ class TradableProduct(str):
         return self.split("/", 1)[1]
 
     def serialize(self) -> msgspec.Raw:
-        return msgspec.Raw(self.encode())
+        return msgspec.Raw(msgspec.json.encode(str(self)))
 
     @staticmethod
     def deserialize(s: str) -> "TradableProduct":

architect_py/graphql_client/juniper_base_client.py

@@ -91,6 +91,10 @@ class JuniperBaseClient:
         exc_tb: object,
     ) -> None:
         await self.http_client.aclose()
+    
+    async def close(self) -> None:
+        """Close the HTTP client connection."""
+        await self.http_client.aclose()
 
     async def execute(
         self,

architect_py/grpc/client.py

@@ -30,6 +30,9 @@ class GrpcClient:
     def set_jwt(self, jwt: str | None):
         self.jwt = jwt
 
+    async def close(self):
+        await self.channel.close()
+
     @staticmethod
     def encoder() -> msgspec.json.Encoder:
         return encoder