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

architect_py/grpc/client.py

@@ -0,0 +1,94 @@
+from types import UnionType
+from typing import AsyncIterator
+
+import grpc
+import msgspec
+
+from . import *
+from .utils import RequestType, ResponseTypeGeneric, decoders, encoder
+
+
+class GrpcClient:
+    endpoint: str
+    channel: grpc.aio.Channel
+    jwt: str | None = None
+
+    def __init__(self, *, host: str, port: int, use_ssl: bool = False):
+        scheme = "https" if use_ssl else "http"
+        self.endpoint = f"{scheme}://{host}:{port}"
+        if use_ssl:
+            credentials = grpc.ssl_channel_credentials()
+            self.channel = grpc.aio.secure_channel(f"{host}:{port}", credentials)
+        else:
+            self.channel = grpc.aio.insecure_channel(f"{host}:{port}")
+
+    def set_jwt(self, jwt: str | None):
+        self.jwt = jwt
+
+    @staticmethod
+    def encoder() -> msgspec.json.Encoder:
+        return encoder
+
+    def get_decoder(
+        self, response_type: type[ResponseTypeGeneric] | UnionType
+    ) -> msgspec.json.Decoder:
+        try:
+            return decoders[response_type]
+        except KeyError:
+            decoder = msgspec.json.Decoder(type=response_type)
+            decoders[response_type] = decoder
+            return decoder
+
+    async def unary_unary(
+        self,
+        request: RequestType[ResponseTypeGeneric],
+    ) -> ResponseTypeGeneric:
+        """
+        Generic function for making a unary RPC call to the gRPC server.
+
+        NB: request_type and ResponseTypeGeneric *cannot* be union types
+        """
+        decoder: msgspec.json.Decoder[ResponseTypeGeneric] = self.get_decoder(
+            request.get_unannotated_response_type()
+        )
+        stub: grpc.aio.UnaryUnaryMultiCallable[
+            RequestType[ResponseTypeGeneric], ResponseTypeGeneric
+        ] = self.channel.unary_unary(
+            request.get_route(),
+            request_serializer=encoder.encode,
+            response_deserializer=decoder.decode,
+        )
+        if self.jwt is not None:
+            metadata = (("authorization", f"Bearer {self.jwt}"),)
+        else:
+            metadata = ()
+        return await stub(request, metadata=metadata)
+
+    async def unary_stream(
+        self,
+        request: RequestType[ResponseTypeGeneric],
+    ) -> AsyncIterator[ResponseTypeGeneric]:
+        """
+        Generic function for subscribing to a stream of updates from the gRPC server.
+
+        NB: request_type and ResponseTypeGeneric *cannot* be union types
+        """
+        decoder: msgspec.json.Decoder[ResponseTypeGeneric] = self.get_decoder(
+            request.get_unannotated_response_type()
+        )
+        stub: grpc.aio.UnaryStreamMultiCallable[
+            RequestType[ResponseTypeGeneric], ResponseTypeGeneric
+        ] = self.channel.unary_stream(
+            request.get_route(),
+            request_serializer=encoder.encode,
+            response_deserializer=decoder.decode,
+        )
+        if self.jwt is not None:
+            metadata = (("authorization", f"Bearer {self.jwt}"),)
+        else:
+            metadata = ()
+        call: grpc.aio._base_call.UnaryStreamCall[
+            RequestType[ResponseTypeGeneric], ResponseTypeGeneric
+        ] = stub(request, metadata=metadata)
+        async for update in call:
+            yield update

architect_py/{grpc_client → grpc/models}/Accounts/AccountsRequest.py

@@ -2,7 +2,7 @@
 #   filename:  Accounts/AccountsRequest.json
 
 from __future__ import annotations
-from architect_py.grpc_client.Accounts.AccountsResponse import AccountsResponse
+from architect_py.grpc.models.Accounts.AccountsResponse import AccountsResponse
 
 from typing import Annotated, Optional
 
@@ -12,6 +12,7 @@ from .. import definitions
 
 
 class AccountsRequest(Struct, omit_defaults=True):
+    paper: Optional[bool] = False
     trader: Optional[
         Annotated[
             Optional[definitions.TraderIdOrEmail],
@@ -24,18 +25,20 @@ class AccountsRequest(Struct, omit_defaults=True):
     Request accounts from the perspective of this trader; if not specified, defaults to the caller user.
     """
 
-    # below is a constructor that takes all field titles as arguments for convenience
+    # Constructor that takes all field titles as arguments for convenience
     @classmethod
     def new(
         cls,
+        paper: Optional[bool] = False,
         trader: Optional[definitions.TraderIdOrEmail] = None,
     ):
         return cls(
+            paper,
             trader,
         )
 
     def __str__(self) -> str:
-        return f"AccountsRequest(trader={self.trader})"
+        return f"AccountsRequest(paper={self.paper},trader={self.trader})"
 
     @staticmethod
     def get_response_type():

architect_py/{grpc_client → grpc/models}/Accounts/AccountsResponse.py

@@ -13,7 +13,7 @@ from .. import definitions
 class AccountsResponse(Struct, omit_defaults=True):
     accounts: List[definitions.AccountWithPermissions]
 
-    # below is a constructor that takes all field titles as arguments for convenience
+    # Constructor that takes all field titles as arguments for convenience
     @classmethod
     def new(
         cls,

architect_py/{grpc_client → grpc/models}/Accounts/__init__.py

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

architect_py/grpc/models/Algo/AlgoOrder.py

@@ -0,0 +1,114 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/AlgoOrder.json
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Annotated, Any, List, Optional
+
+from msgspec import Meta, Struct
+
+from .. import definitions
+
+
+class AlgoOrder(Struct, omit_defaults=True):
+    algo: str
+    create_time: datetime
+    id: definitions.OrderId
+    num_errors: Annotated[int, Meta(ge=0)]
+    num_open_orders: Annotated[int, Meta(ge=0)]
+    num_rejects: Annotated[int, Meta(ge=0)]
+    num_sent_orders: Annotated[int, Meta(ge=0)]
+    params: Any
+    status: definitions.AlgoOrderStatus
+    status_details: Any
+    trader: definitions.UserId
+    display_symbols: Optional[List[str]] = None
+    finish_success: Optional[
+        Annotated[
+            Optional[bool],
+            Meta(
+                description="If the algo order is stopped, whether the stop was successful."
+            ),
+        ]
+    ] = None
+    """
+    If the algo order is stopped, whether the stop was successful.
+    """
+    finish_time: Optional[
+        Annotated[
+            Optional[datetime],
+            Meta(
+                description="If the algo order is stopped, the time at which it was stopped."
+            ),
+        ]
+    ] = None
+    """
+    If the algo order is stopped, the time at which it was stopped.
+    """
+    parent_id: Optional[definitions.OrderId] = None
+    reject_or_error_reason: Optional[
+        Annotated[
+            Optional[str],
+            Meta(
+                description="If algo order status is rejected, contains the reject reason; for algo orders that finished unsuccessfully, contains the error reason."
+            ),
+        ]
+    ] = None
+    """
+    If algo order status is rejected, contains the reject reason; for algo orders that finished unsuccessfully, contains the error reason.
+    """
+    working_progress: Optional[
+        Annotated[
+            Optional[float],
+            Meta(description="Progress of the algo, 0.0 to 1.0, if computable"),
+        ]
+    ] = None
+    """
+    Progress of the algo, 0.0 to 1.0, if computable
+    """
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo: str,
+        create_time: datetime,
+        id: definitions.OrderId,
+        num_errors: int,
+        num_open_orders: int,
+        num_rejects: int,
+        num_sent_orders: int,
+        params: Any,
+        status: definitions.AlgoOrderStatus,
+        status_details: Any,
+        trader: definitions.UserId,
+        display_symbols: Optional[List[str]] = None,
+        finish_success: Optional[bool] = None,
+        finish_time: Optional[datetime] = None,
+        parent_id: Optional[definitions.OrderId] = None,
+        reject_or_error_reason: Optional[str] = None,
+        working_progress: Optional[float] = None,
+    ):
+        return cls(
+            algo,
+            create_time,
+            id,
+            num_errors,
+            num_open_orders,
+            num_rejects,
+            num_sent_orders,
+            params,
+            status,
+            status_details,
+            trader,
+            display_symbols,
+            finish_success,
+            finish_time,
+            parent_id,
+            reject_or_error_reason,
+            working_progress,
+        )
+
+    def __str__(self) -> str:
+        return f"AlgoOrder(algo={self.algo},create_time={self.create_time},id={self.id},num_errors={self.num_errors},num_open_orders={self.num_open_orders},num_rejects={self.num_rejects},num_sent_orders={self.num_sent_orders},params={self.params},status={self.status},status_details={self.status_details},trader={self.trader},display_symbols={self.display_symbols},finish_success={self.finish_success},finish_time={self.finish_time},parent_id={self.parent_id},reject_or_error_reason={self.reject_or_error_reason},working_progress={self.working_progress})"

architect_py/grpc/models/Algo/AlgoOrderRequest.py

@@ -0,0 +1,46 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/AlgoOrderRequest.json
+
+from __future__ import annotations
+from architect_py.grpc.models.Algo.AlgoOrder import AlgoOrder
+
+from msgspec import Struct
+
+from .. import definitions
+
+
+class AlgoOrderRequest(Struct, omit_defaults=True):
+    """
+    Get generic algo run status
+    """
+
+    algo_order_id: definitions.OrderId
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo_order_id: definitions.OrderId,
+    ):
+        return cls(
+            algo_order_id,
+        )
+
+    def __str__(self) -> str:
+        return f"AlgoOrderRequest(algo_order_id={self.algo_order_id})"
+
+    @staticmethod
+    def get_response_type():
+        return AlgoOrder
+
+    @staticmethod
+    def get_unannotated_response_type():
+        return AlgoOrder
+
+    @staticmethod
+    def get_route() -> str:
+        return "/json.architect.Algo/AlgoOrder"
+
+    @staticmethod
+    def get_rpc_method():
+        return "unary"

architect_py/grpc/models/Algo/AlgoOrdersRequest.py

@@ -0,0 +1,72 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/AlgoOrdersRequest.json
+
+from __future__ import annotations
+from architect_py.grpc.models.Algo.AlgoOrdersResponse import AlgoOrdersResponse
+
+from datetime import datetime
+from typing import List, Optional
+
+from msgspec import Struct
+
+from .. import definitions
+
+
+class AlgoOrdersRequest(Struct, omit_defaults=True):
+    """
+    Find all algo orders matching the given criteria.
+
+    If limit is not specified, it will default to 100.
+    """
+
+    algo: Optional[str] = None
+    display_symbol: Optional[str] = None
+    from_inclusive: Optional[datetime] = None
+    limit: Optional[int] = None
+    parent_order_id: Optional[definitions.OrderId] = None
+    status: Optional[List[definitions.AlgoOrderStatus]] = None
+    to_exclusive: Optional[datetime] = None
+    trader: Optional[definitions.TraderIdOrEmail] = None
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo: Optional[str] = None,
+        display_symbol: Optional[str] = None,
+        from_inclusive: Optional[datetime] = None,
+        limit: Optional[int] = None,
+        parent_order_id: Optional[definitions.OrderId] = None,
+        status: Optional[List[definitions.AlgoOrderStatus]] = None,
+        to_exclusive: Optional[datetime] = None,
+        trader: Optional[definitions.TraderIdOrEmail] = None,
+    ):
+        return cls(
+            algo,
+            display_symbol,
+            from_inclusive,
+            limit,
+            parent_order_id,
+            status,
+            to_exclusive,
+            trader,
+        )
+
+    def __str__(self) -> str:
+        return f"AlgoOrdersRequest(algo={self.algo},display_symbol={self.display_symbol},from_inclusive={self.from_inclusive},limit={self.limit},parent_order_id={self.parent_order_id},status={self.status},to_exclusive={self.to_exclusive},trader={self.trader})"
+
+    @staticmethod
+    def get_response_type():
+        return AlgoOrdersResponse
+
+    @staticmethod
+    def get_unannotated_response_type():
+        return AlgoOrdersResponse
+
+    @staticmethod
+    def get_route() -> str:
+        return "/json.architect.Algo/AlgoOrders"
+
+    @staticmethod
+    def get_rpc_method():
+        return "unary"

architect_py/grpc/models/Algo/AlgoOrdersResponse.py

@@ -0,0 +1,27 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/AlgoOrdersResponse.json
+
+from __future__ import annotations
+
+from typing import List
+
+from msgspec import Struct
+
+from .AlgoOrder import AlgoOrder
+
+
+class AlgoOrdersResponse(Struct, omit_defaults=True):
+    algo_orders: List[AlgoOrder]
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo_orders: List[AlgoOrder],
+    ):
+        return cls(
+            algo_orders,
+        )
+
+    def __str__(self) -> str:
+        return f"AlgoOrdersResponse(algo_orders={self.algo_orders})"

architect_py/grpc/models/Algo/CreateAlgoOrderRequest.py

@@ -0,0 +1,56 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/CreateAlgoOrderRequest.json
+
+from __future__ import annotations
+from architect_py.grpc.models.Algo.AlgoOrder import AlgoOrder
+
+from typing import Any, Optional
+
+from msgspec import Struct
+
+from .. import definitions
+
+
+class CreateAlgoOrderRequest(Struct, omit_defaults=True):
+    algo: str
+    params: Any
+    id: Optional[definitions.OrderId] = None
+    parent_id: Optional[definitions.OrderId] = None
+    trader: Optional[definitions.TraderIdOrEmail] = None
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo: str,
+        params: Any,
+        id: Optional[definitions.OrderId] = None,
+        parent_id: Optional[definitions.OrderId] = None,
+        trader: Optional[definitions.TraderIdOrEmail] = None,
+    ):
+        return cls(
+            algo,
+            params,
+            id,
+            parent_id,
+            trader,
+        )
+
+    def __str__(self) -> str:
+        return f"CreateAlgoOrderRequest(algo={self.algo},params={self.params},id={self.id},parent_id={self.parent_id},trader={self.trader})"
+
+    @staticmethod
+    def get_response_type():
+        return AlgoOrder
+
+    @staticmethod
+    def get_unannotated_response_type():
+        return AlgoOrder
+
+    @staticmethod
+    def get_route() -> str:
+        return "/json.architect.Algo/CreateAlgoOrder"
+
+    @staticmethod
+    def get_rpc_method():
+        return "unary"

architect_py/grpc/models/Algo/PauseAlgoRequest.py

@@ -0,0 +1,42 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/PauseAlgoRequest.json
+
+from __future__ import annotations
+from architect_py.grpc.models.Algo.PauseAlgoResponse import PauseAlgoResponse
+
+from msgspec import Struct
+
+from .. import definitions
+
+
+class PauseAlgoRequest(Struct, omit_defaults=True):
+    algo_order_id: definitions.OrderId
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo_order_id: definitions.OrderId,
+    ):
+        return cls(
+            algo_order_id,
+        )
+
+    def __str__(self) -> str:
+        return f"PauseAlgoRequest(algo_order_id={self.algo_order_id})"
+
+    @staticmethod
+    def get_response_type():
+        return PauseAlgoResponse
+
+    @staticmethod
+    def get_unannotated_response_type():
+        return PauseAlgoResponse
+
+    @staticmethod
+    def get_route() -> str:
+        return "/json.architect.Algo/PauseAlgo"
+
+    @staticmethod
+    def get_rpc_method():
+        return "unary"

architect_py/grpc/models/Algo/PauseAlgoResponse.py

@@ -0,0 +1,20 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/PauseAlgoResponse.json
+
+from __future__ import annotations
+
+from msgspec import Struct
+
+
+class PauseAlgoResponse(Struct, omit_defaults=True):
+    pass
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+    ):
+        return cls()
+
+    def __str__(self) -> str:
+        return f"PauseAlgoResponse()"

architect_py/grpc/models/Algo/StartAlgoRequest.py

@@ -0,0 +1,42 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/StartAlgoRequest.json
+
+from __future__ import annotations
+from architect_py.grpc.models.Algo.StartAlgoResponse import StartAlgoResponse
+
+from msgspec import Struct
+
+from .. import definitions
+
+
+class StartAlgoRequest(Struct, omit_defaults=True):
+    algo_order_id: definitions.OrderId
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo_order_id: definitions.OrderId,
+    ):
+        return cls(
+            algo_order_id,
+        )
+
+    def __str__(self) -> str:
+        return f"StartAlgoRequest(algo_order_id={self.algo_order_id})"
+
+    @staticmethod
+    def get_response_type():
+        return StartAlgoResponse
+
+    @staticmethod
+    def get_unannotated_response_type():
+        return StartAlgoResponse
+
+    @staticmethod
+    def get_route() -> str:
+        return "/json.architect.Algo/StartAlgo"
+
+    @staticmethod
+    def get_rpc_method():
+        return "unary"

architect_py/grpc/models/Algo/StartAlgoResponse.py

@@ -0,0 +1,20 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/StartAlgoResponse.json
+
+from __future__ import annotations
+
+from msgspec import Struct
+
+
+class StartAlgoResponse(Struct, omit_defaults=True):
+    pass
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+    ):
+        return cls()
+
+    def __str__(self) -> str:
+        return f"StartAlgoResponse()"

architect_py/grpc/models/Algo/StopAlgoRequest.py

@@ -0,0 +1,42 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/StopAlgoRequest.json
+
+from __future__ import annotations
+from architect_py.grpc.models.Algo.StopAlgoResponse import StopAlgoResponse
+
+from msgspec import Struct
+
+from .. import definitions
+
+
+class StopAlgoRequest(Struct, omit_defaults=True):
+    algo_order_id: definitions.OrderId
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+        algo_order_id: definitions.OrderId,
+    ):
+        return cls(
+            algo_order_id,
+        )
+
+    def __str__(self) -> str:
+        return f"StopAlgoRequest(algo_order_id={self.algo_order_id})"
+
+    @staticmethod
+    def get_response_type():
+        return StopAlgoResponse
+
+    @staticmethod
+    def get_unannotated_response_type():
+        return StopAlgoResponse
+
+    @staticmethod
+    def get_route() -> str:
+        return "/json.architect.Algo/StopAlgo"
+
+    @staticmethod
+    def get_rpc_method():
+        return "unary"

architect_py/grpc/models/Algo/StopAlgoResponse.py

@@ -0,0 +1,20 @@
+# generated by datamodel-codegen:
+#   filename:  Algo/StopAlgoResponse.json
+
+from __future__ import annotations
+
+from msgspec import Struct
+
+
+class StopAlgoResponse(Struct, omit_defaults=True):
+    pass
+
+    # Constructor that takes all field titles as arguments for convenience
+    @classmethod
+    def new(
+        cls,
+    ):
+        return cls()
+
+    def __str__(self) -> str:
+        return f"StopAlgoResponse()"

architect_py/{grpc_client → grpc/models}/Algo/__init__.py

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