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

templates/exceptions.py

@@ -0,0 +1,83 @@
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+
+class GraphQLClientError(Exception):
+    """Base exception."""
+
+
+class GraphQLClientHttpError(GraphQLClientError):
+    def __init__(self, status_code: int, response: httpx.Response) -> None:
+        self.status_code = status_code
+        self.response = response
+
+    def __str__(self) -> str:
+        return f"HTTP status code: {self.status_code}"
+
+
+class GraphQLClientInvalidResponseError(GraphQLClientError):
+    def __init__(self, response: httpx.Response) -> None:
+        self.response = response
+
+    def __str__(self) -> str:
+        return "Invalid response format."
+
+
+class GraphQLClientGraphQLError(GraphQLClientError):
+    def __init__(
+        self,
+        message: str,
+        locations: Optional[List[Dict[str, int]]] = None,
+        path: Optional[List[str]] = None,
+        extensions: Optional[Dict[str, object]] = None,
+        orginal: Optional[Dict[str, object]] = None,
+    ):
+        self.message = message
+        self.locations = locations
+        self.path = path
+        self.extensions = extensions
+        self.orginal = orginal
+
+    def __str__(self) -> str:
+        return self.message
+
+    @classmethod
+    def from_dict(cls, error: Dict[str, Any]) -> "GraphQLClientGraphQLError":
+        return cls(
+            message=error["message"],
+            locations=error.get("locations"),
+            path=error.get("path"),
+            extensions=error.get("extensions"),
+            orginal=error,
+        )
+
+
+class GraphQLClientGraphQLMultiError(GraphQLClientError):
+    def __init__(
+        self,
+        errors: List[GraphQLClientGraphQLError],
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        self.errors = errors
+        self.data = data
+
+    def __str__(self) -> str:
+        return "; ".join(str(e) for e in self.errors)
+
+    @classmethod
+    def from_errors_dicts(
+        cls, errors_dicts: List[Dict[str, Any]], data: Optional[Dict[str, Any]] = None
+    ) -> "GraphQLClientGraphQLMultiError":
+        return cls(
+            errors=[GraphQLClientGraphQLError.from_dict(e) for e in errors_dicts],
+            data=data,
+        )
+
+
+class GraphQLClientInvalidMessageFormat(GraphQLClientError):
+    def __init__(self, message: Union[str, bytes]) -> None:
+        self.message = message
+
+    def __str__(self) -> str:
+        return "Invalid message format."

templates/juniper_base_client.py

@@ -0,0 +1,371 @@
+"""
+Changes made from default base client:
+- Corrected the `Self` type variable from the `JuniperBaseClient` class
+- Removed the try-except block from importing websockets
+- Removed the # Generated by ariadne-codegen at top
+- Redid init to add auth + port
+"""
+
+import enum
+import json
+from typing import Any, AsyncIterator, cast, Dict, IO, List, Optional, Tuple, TypeVar
+from uuid import uuid4
+
+import httpx
+from pydantic import BaseModel
+from pydantic_core import to_jsonable_python
+
+from websockets.client import (  # type: ignore[import-not-found,unused-ignore]
+    connect as ws_connect,
+    WebSocketClientProtocol,
+)
+from websockets.typing import (  # type: ignore[import-not-found,unused-ignore]
+    Data,
+    Origin,
+    Subprotocol,
+)
+
+from architect_py.graphql_client.base_model import UNSET, Upload
+from .exceptions import (
+    GraphQLClientGraphQLMultiError,
+    GraphQLClientHttpError,
+    GraphQLClientInvalidMessageFormat,
+    GraphQLClientInvalidResponseError,
+)
+
+Self = TypeVar("Self", bound="JuniperBaseClient")
+
+GRAPHQL_TRANSPORT_WS = "graphql-transport-ws"
+
+
+class GraphQLTransportWSMessageType(str, enum.Enum):
+    CONNECTION_INIT = "connection_init"
+    CONNECTION_ACK = "connection_ack"
+    PING = "ping"
+    PONG = "pong"
+    SUBSCRIBE = "subscribe"
+    NEXT = "next"
+    ERROR = "error"
+    COMPLETE = "complete"
+
+
+class JuniperBaseClient:
+    def __init__(
+        self,
+        host: str = "",
+        port: int = 4567,
+        use_tls: bool = True,
+        api_key: Optional[str] = None,
+        api_secret: Optional[str] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+        ws_origin: Optional[str] = None,
+    ) -> None:
+        protocol = "https" if use_tls else "http"
+        self.url = f"{protocol}://{host}:{port}/graphql"
+        self.headers = {}
+        if api_key and api_secret:
+            self.headers["Authorization"] = f"Basic {api_key} {api_secret}"
+        self.http_client = (
+            http_client if http_client else httpx.AsyncClient(headers=self.headers)
+        )
+
+        ws_protocol = "wss" if use_tls else "ws"
+        self.ws_url = f"{ws_protocol}://{host}:{port}/subscriptions/graphql"
+        self.ws_headers: dict = {}  # CR acho: I don't think this does anything
+        self.ws_origin = Origin(ws_origin) if ws_origin else None
+        self.ws_connection_init_payload: dict[str, str] = {}
+        if api_key and api_secret:
+            self.ws_connection_init_payload["authorization"] = (
+                f"Basic {api_key} {api_secret}"
+            )
+
+    async def __aenter__(self: Self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: object,
+        exc_val: object,
+        exc_tb: object,
+    ) -> None:
+        await self.http_client.aclose()
+
+    async def execute(
+        self,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        processed_variables, files, files_map = self._process_variables(variables)
+
+        if files and files_map:
+            return await self._execute_multipart(
+                query=query,
+                operation_name=operation_name,
+                variables=processed_variables,
+                files=files,
+                files_map=files_map,
+                **kwargs,
+            )
+
+        return await self._execute_json(
+            query=query,
+            operation_name=operation_name,
+            variables=processed_variables,
+            **kwargs,
+        )
+
+    def get_data(self, response: httpx.Response) -> Dict[str, Any]:
+        if not response.is_success:
+            raise GraphQLClientHttpError(
+                status_code=response.status_code, response=response
+            )
+
+        try:
+            response_json = response.json()
+        except ValueError as exc:
+            raise GraphQLClientInvalidResponseError(response=response) from exc
+
+        if (not isinstance(response_json, dict)) or (
+            "data" not in response_json and "errors" not in response_json
+        ):
+            raise GraphQLClientInvalidResponseError(response=response)
+
+        data = response_json.get("data")
+        errors = response_json.get("errors")
+
+        if errors:
+            raise GraphQLClientGraphQLMultiError.from_errors_dicts(
+                errors_dicts=errors, data=data
+            )
+
+        return cast(Dict[str, Any], data)
+
+    async def execute_ws(
+        self,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        headers = self.ws_headers.copy()
+        headers.update(kwargs.get("extra_headers", {}))
+
+        merged_kwargs: Dict[str, Any] = {"origin": self.ws_origin}
+        merged_kwargs.update(kwargs)
+        merged_kwargs["extra_headers"] = headers
+        merged_kwargs["ping_interval"] = None
+
+        operation_id = str(uuid4())
+        async with ws_connect(
+            self.ws_url,
+            subprotocols=[Subprotocol(GRAPHQL_TRANSPORT_WS)],
+            **merged_kwargs,
+        ) as websocket:
+            await self._send_connection_init(websocket)
+            # wait for connection_ack from server
+            await self._handle_ws_message(
+                await websocket.recv(),
+                websocket,
+                expected_type=GraphQLTransportWSMessageType.CONNECTION_ACK,
+            )
+            await self._send_subscribe(
+                websocket,
+                operation_id=operation_id,
+                query=query,
+                operation_name=operation_name,
+                variables=variables,
+            )
+
+            async for message in websocket:
+                data = await self._handle_ws_message(message, websocket)
+                if data:
+                    yield data
+
+    def _process_variables(
+        self, variables: Optional[Dict[str, Any]]
+    ) -> Tuple[
+        Dict[str, Any], Dict[str, Tuple[str, IO[bytes], str]], Dict[str, List[str]]
+    ]:
+        if not variables:
+            return {}, {}, {}
+
+        serializable_variables = self._convert_dict_to_json_serializable(variables)
+        return self._get_files_from_variables(serializable_variables)
+
+    def _convert_dict_to_json_serializable(
+        self, dict_: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return {
+            key: self._convert_value(value)
+            for key, value in dict_.items()
+            if value is not UNSET
+        }
+
+    def _convert_value(self, value: Any) -> Any:
+        if isinstance(value, BaseModel):
+            return value.model_dump(by_alias=True, exclude_unset=True)
+        if isinstance(value, list):
+            return [self._convert_value(item) for item in value]
+        return value
+
+    def _get_files_from_variables(
+        self, variables: Dict[str, Any]
+    ) -> Tuple[
+        Dict[str, Any], Dict[str, Tuple[str, IO[bytes], str]], Dict[str, List[str]]
+    ]:
+        files_map: Dict[str, List[str]] = {}
+        files_list: List[Upload] = []
+
+        def separate_files(path: str, obj: Any) -> Any:
+            if isinstance(obj, list):
+                nulled_list = []
+                for index, value in enumerate(obj):
+                    value = separate_files(f"{path}.{index}", value)
+                    nulled_list.append(value)
+                return nulled_list
+
+            if isinstance(obj, dict):
+                nulled_dict = {}
+                for key, value in obj.items():
+                    value = separate_files(f"{path}.{key}", value)
+                    nulled_dict[key] = value
+                return nulled_dict
+
+            if isinstance(obj, Upload):
+                if obj in files_list:
+                    file_index = files_list.index(obj)
+                    files_map[str(file_index)].append(path)
+                else:
+                    file_index = len(files_list)
+                    files_list.append(obj)
+                    files_map[str(file_index)] = [path]
+                return None
+
+            return obj
+
+        nulled_variables = separate_files("variables", variables)
+        files: Dict[str, Tuple[str, IO[bytes], str]] = {
+            str(i): (file_.filename, cast(IO[bytes], file_.content), file_.content_type)
+            for i, file_ in enumerate(files_list)
+        }
+        return nulled_variables, files, files_map
+
+    async def _execute_multipart(
+        self,
+        query: str,
+        operation_name: Optional[str],
+        variables: Dict[str, Any],
+        files: Dict[str, Tuple[str, IO[bytes], str]],
+        files_map: Dict[str, List[str]],
+        **kwargs: Any,
+    ) -> httpx.Response:
+        data = {
+            "operations": json.dumps(
+                {
+                    "query": query,
+                    "operationName": operation_name,
+                    "variables": variables,
+                },
+                default=to_jsonable_python,
+            ),
+            "map": json.dumps(files_map, default=to_jsonable_python),
+        }
+
+        return await self.http_client.post(
+            url=self.url, data=data, files=files, **kwargs
+        )
+
+    async def _execute_json(
+        self,
+        query: str,
+        operation_name: Optional[str],
+        variables: Dict[str, Any],
+        **kwargs: Any,
+    ) -> httpx.Response:
+        headers: Dict[str, str] = {"Content-Type": "application/json"}
+        headers.update(kwargs.get("headers", {}))
+
+        merged_kwargs: Dict[str, Any] = kwargs.copy()
+        merged_kwargs["headers"] = headers
+
+        return await self.http_client.post(
+            url=self.url,
+            content=json.dumps(
+                {
+                    "query": query,
+                    "operationName": operation_name,
+                    "variables": variables,
+                },
+                default=to_jsonable_python,
+            ),
+            **merged_kwargs,
+        )
+
+    async def _send_connection_init(self, websocket: WebSocketClientProtocol) -> None:
+        payload: Dict[str, Any] = {
+            "type": GraphQLTransportWSMessageType.CONNECTION_INIT.value
+        }
+        if self.ws_connection_init_payload:
+            payload["payload"] = self.ws_connection_init_payload
+        await websocket.send(json.dumps(payload))
+
+    async def _send_subscribe(
+        self,
+        websocket: WebSocketClientProtocol,
+        operation_id: str,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        payload: Dict[str, Any] = {
+            "id": operation_id,
+            "type": GraphQLTransportWSMessageType.SUBSCRIBE.value,
+            "payload": {"query": query, "operationName": operation_name},
+        }
+        if variables:
+            payload["payload"]["variables"] = self._convert_dict_to_json_serializable(
+                variables
+            )
+        await websocket.send(json.dumps(payload))
+
+    async def _handle_ws_message(
+        self,
+        message: Data,
+        websocket: WebSocketClientProtocol,
+        expected_type: Optional[GraphQLTransportWSMessageType] = None,
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            message_dict = json.loads(message)
+        except json.JSONDecodeError as exc:
+            raise GraphQLClientInvalidMessageFormat(message=message) from exc
+
+        type_ = message_dict.get("type")
+        payload = message_dict.get("payload", {})
+
+        if not type_ or type_ not in {t.value for t in GraphQLTransportWSMessageType}:
+            raise GraphQLClientInvalidMessageFormat(message=message)
+
+        if expected_type and expected_type != type_:
+            raise GraphQLClientInvalidMessageFormat(
+                f"Invalid message received. Expected: {expected_type.value}"
+            )
+
+        if type_ == GraphQLTransportWSMessageType.NEXT:
+            if "data" not in payload:
+                raise GraphQLClientInvalidMessageFormat(message=message)
+            return cast(Dict[str, Any], payload["data"])
+
+        if type_ == GraphQLTransportWSMessageType.COMPLETE:
+            await websocket.close()
+        elif type_ == GraphQLTransportWSMessageType.PING:
+            await websocket.send(
+                json.dumps({"type": GraphQLTransportWSMessageType.PONG.value})
+            )
+        elif type_ == GraphQLTransportWSMessageType.ERROR:
+            raise GraphQLClientGraphQLMultiError.from_errors_dicts(
+                errors_dicts=payload, data=message_dict
+            )
+
+        return None

architect_py/client_protocol.py

@@ -1,53 +0,0 @@
-# fmt: off
-
-# mypy: ignore-errors
-
-# Autogenerated from generate_protocol.py
-
-# If you are here for function definitions, please refer to architect_py/async_cline.py
-# This file is so that the sync client has good type hinting
-# It is not used for anything else
-# For maintainers: ensure that the types in this file are correct for correct type hinting
-
-
-from architect_py.graphql_client import *
-from architect_py.async_client import *
-
-
-class AsyncClientProtocol:
-    def cancel_all_orders(self) -> bool: ...
-    def cancel_order(self, order_id: str) -> CancelFields: ...
-    @staticmethod
-    def connect(*, api_key: str, api_secret: str, paper_trading: bool, host: str = 'app.architect.co', grpc_endpoint: str = 'cme.marketdata.architect.co', _port: Optional[int] = None, **kwargs: Any) -> AsyncClient: ...
-    def enable_orderflow(self) -> Any: ...
-    def get_account_history(self, account: str, from_inclusive: Optional[datetime] = None, to_exclusive: Optional[datetime] = None) -> Sequence[AccountSummaryFields]: ...
-    def get_account_summaries(self, accounts: Optional[list[str]] = None, trader: Optional[str] = None) -> Sequence[AccountSummaryFields]: ...
-    def get_account_summary(self, account: str) -> AccountSummaryFields: ...
-    def get_all_open_orders(self) -> Sequence[OrderFields]: ...
-    def get_cme_first_notice_date(self, symbol: str) -> Optional[date]: ...
-    def get_cme_future_from_root_month_year(self, root: str, month: int, year: int) -> str: ...
-    def get_cme_futures_series(self, series: str) -> list[tuple[date, str]]: ...
-    def get_execution_info(self, symbol: TradableProduct, execution_venue: str) -> Optional[ExecutionInfoFields]: ...
-    def get_execution_infos(self, symbols: Optional[list[TradableProduct]], execution_venue: Optional[str] = None) -> Sequence[ExecutionInfoFields]: ...
-    @staticmethod
-    def get_expiration_from_CME_name(name: str) -> date: ...
-    def get_fills(self, from_inclusive: Optional[datetime], to_exclusive: Optional[datetime], venue: Optional[str] = None, account: Optional[str] = None, order_id: Optional[str] = None) -> GetFillsQueryFolioHistoricalFills: ...
-    def get_future_series(self, series_symbol: str) -> list[str]: ...
-    def get_historical_candles(self, symbol: str, candle_width: CandleWidth, start: datetime, end: datetime) -> HistoricalCandlesResponse: ...
-    def get_historical_orders(self, order_ids: Optional[list[str]] = None, from_inclusive: Optional[datetime] = None, to_exclusive: Optional[datetime] = None, venue: Optional[str] = None, account: Optional[str] = None, parent_order_id: Optional[str] = None) -> Sequence[OrderFields]: ...
-    def get_l1_book_snapshot(self, symbol: str, venue: str) -> MarketTickerFields: ...
-    def get_l1_book_snapshots(self, symbols: list[str], venue: str) -> Sequence[MarketTickerFields]: ...
-    def get_l2_book_snapshot(self, symbol: str, venue: str) -> L2BookFields: ...
-    def get_market_snapshot(self, symbol: TradableProduct, venue: str) -> MarketTickerFields: ...
-    def get_market_snapshots(self, symbols: list[TradableProduct], venue: str) -> Sequence[MarketTickerFields]: ...
-    def get_market_status(self, symbol: TradableProduct, venue: str) -> MarketStatusFields: ...
-    def get_open_orders(self, order_ids: Optional[list[str]] = None, venue: Optional[str] = None, account: Optional[str] = None, trader: Optional[str] = None, symbol: Optional[str] = None, parent_order_id: Optional[str] = None) -> Sequence[OrderFields]: ...
-    def get_order(self, order_id: str) -> Optional[OrderFields]: ...
-    def get_orders(self, order_ids: list[str]) -> list[Optional[OrderFields]]: ...
-    def get_product_info(self, symbol: str) -> Optional[ProductInfoFields]: ...
-    def get_product_infos(self, symbols: Optional[list[str]]) -> Sequence[ProductInfoFields]: ...
-    def list_accounts(self) -> Sequence[AccountWithPermissionsFields]: ...
-    def search_symbols(self, search_string: Optional[str] = None, execution_venue: Optional[str] = None, offset: int = 0, limit: int = 20) -> list[TradableProduct]: ...
-    def send_limit_order(self, *, id: Optional[str] = None, symbol: TradableProduct, execution_venue: Optional[str], odir: OrderDir, quantity: Decimal, limit_price: Decimal, order_type: OrderType = OrderType.LIMIT, time_in_force: TimeInForce = TimeInForce.DAY, good_til_date: Optional[datetime] = None, price_round_method: Optional[TickRoundMethod] = None, account: Optional[str] = None, trader: Optional[str] = None, post_only: bool = False, trigger_price: Optional[Decimal] = None) -> OrderFields: ...
-    def send_market_pro_order(self, *, id: Optional[str] = None, symbol: TradableProduct, execution_venue: str, odir: OrderDir, quantity: Decimal, time_in_force: TimeInForce = TimeInForce.DAY, account: Optional[str] = None, fraction_through_market: Decimal = Decimal('0.001')) -> OrderFields: ...
-    def who_am_i(self) -> tuple[str, str]: ...

architect_py/grpc_client/Algo/AlgoOrderForTwapAlgo.py

@@ -1,61 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  Algo/AlgoOrderForTwapAlgo.json
-
-from __future__ import annotations
-
-from datetime import datetime
-from typing import List, Optional
-
-from msgspec import Struct
-
-from .. import definitions
-
-
-class AlgoOrderForTwapAlgo(Struct, omit_defaults=True):
-    account: str
-    algo_name: str
-    algo_order_id: definitions.OrderId
-    create_time: datetime
-    params: definitions.TwapParams
-    state: definitions.AlgoState
-    status: definitions.TwapStatus
-    trader: definitions.UserId
-    display_symbols: Optional[List[str]] = None
-    last_error: Optional[str] = None
-    last_error_time: Optional[datetime] = None
-    parent_order_id: Optional[definitions.OrderId] = None
-
-    # below is a constructor that takes all field titles as arguments for convenience
-    @classmethod
-    def new(
-        cls,
-        account: str,
-        algo_name: str,
-        algo_order_id: definitions.OrderId,
-        create_time: datetime,
-        params: definitions.TwapParams,
-        state: definitions.AlgoState,
-        status: definitions.TwapStatus,
-        trader: definitions.UserId,
-        display_symbols: Optional[List[str]] = None,
-        last_error: Optional[str] = None,
-        last_error_time: Optional[datetime] = None,
-        parent_order_id: Optional[definitions.OrderId] = None,
-    ):
-        return cls(
-            account,
-            algo_name,
-            algo_order_id,
-            create_time,
-            params,
-            state,
-            status,
-            trader,
-            display_symbols,
-            last_error,
-            last_error_time,
-            parent_order_id,
-        )
-
-    def __str__(self) -> str:
-        return f"AlgoOrderForTwapAlgo(account={self.account},algo_name={self.algo_name},algo_order_id={self.algo_order_id},create_time={self.create_time},params={self.params},state={self.state},status={self.status},trader={self.trader},display_symbols={self.display_symbols},last_error={self.last_error},last_error_time={self.last_error_time},parent_order_id={self.parent_order_id})"

architect_py/grpc_client/Algo/CreateAlgoOrderRequestForTwapAlgo.py

@@ -1,59 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  Algo/CreateAlgoOrderRequestForTwapAlgo.json
-
-from __future__ import annotations
-from architect_py.grpc_client.Algo.AlgoOrderForTwapAlgo import AlgoOrderForTwapAlgo
-
-from typing import Optional
-
-from msgspec import Struct
-
-from .. import definitions
-
-
-class CreateAlgoOrderRequestForTwapAlgo(Struct, omit_defaults=True):
-    algo_name: str
-    params: definitions.TwapParams
-    account: Optional[str] = None
-    algo_order_id: Optional[definitions.OrderId] = None
-    parent_order_id: Optional[definitions.OrderId] = None
-    trader: Optional[definitions.UserId] = None
-
-    # below is a constructor that takes all field titles as arguments for convenience
-    @classmethod
-    def new(
-        cls,
-        algo_name: str,
-        params: definitions.TwapParams,
-        account: Optional[str] = None,
-        algo_order_id: Optional[definitions.OrderId] = None,
-        parent_order_id: Optional[definitions.OrderId] = None,
-        trader: Optional[definitions.UserId] = None,
-    ):
-        return cls(
-            algo_name,
-            params,
-            account,
-            algo_order_id,
-            parent_order_id,
-            trader,
-        )
-
-    def __str__(self) -> str:
-        return f"CreateAlgoOrderRequestForTwapAlgo(algo_name={self.algo_name},params={self.params},account={self.account},algo_order_id={self.algo_order_id},parent_order_id={self.parent_order_id},trader={self.trader})"
-
-    @staticmethod
-    def get_response_type():
-        return AlgoOrderForTwapAlgo
-
-    @staticmethod
-    def get_unannotated_response_type():
-        return AlgoOrderForTwapAlgo
-
-    @staticmethod
-    def get_route() -> str:
-        return "/json.architect.Algo/CreateTwapAlgoOrder"
-
-    @staticmethod
-    def get_rpc_method():
-        return "unary"

architect_py/grpc_client/Algo/ModifyAlgoOrderRequestForTwapAlgo.py

@@ -1,45 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  Algo/ModifyAlgoOrderRequestForTwapAlgo.json
-
-from __future__ import annotations
-from architect_py.grpc_client.Algo.AlgoOrderForTwapAlgo import AlgoOrderForTwapAlgo
-
-from msgspec import Struct
-
-from .. import definitions
-
-
-class ModifyAlgoOrderRequestForTwapAlgo(Struct, omit_defaults=True):
-    algo_order_id: definitions.OrderId
-    params: definitions.TwapParams
-
-    # below is a constructor that takes all field titles as arguments for convenience
-    @classmethod
-    def new(
-        cls,
-        algo_order_id: definitions.OrderId,
-        params: definitions.TwapParams,
-    ):
-        return cls(
-            algo_order_id,
-            params,
-        )
-
-    def __str__(self) -> str:
-        return f"ModifyAlgoOrderRequestForTwapAlgo(algo_order_id={self.algo_order_id},params={self.params})"
-
-    @staticmethod
-    def get_response_type():
-        return AlgoOrderForTwapAlgo
-
-    @staticmethod
-    def get_unannotated_response_type():
-        return AlgoOrderForTwapAlgo
-
-    @staticmethod
-    def get_route() -> str:
-        return "/json.architect.Algo/ModifyTwapAlgoOrder"
-
-    @staticmethod
-    def get_rpc_method():
-        return "unary"

architect_py/grpc_client/Health/__init__.py

@@ -1,2 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  processed_schemas

architect_py/grpc_client/Marketdata/__init__.py

@@ -1,2 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  processed_schemas