# pylint:disable=redefined-builtin,too-many-lines import asyncio from datetime import datetime from typing import AsyncGenerator, AsyncIterable, List, Optional import grpc from deprecation import deprecated from . import _grpc_helpers, utils from ._error_hub import handle_aio_error_hub_gen from ._errors import handle_aio_request_error, handle_aio_request_error_gen from .exceptions import RequestError from .grpc import ( instruments_pb2, instruments_pb2_grpc, marketdata_pb2, marketdata_pb2_grpc, operations_pb2, operations_pb2_grpc, orders_pb2, orders_pb2_grpc, sandbox_pb2, sandbox_pb2_grpc, signals_pb2, signals_pb2_grpc, stoporders_pb2, stoporders_pb2_grpc, users_pb2, users_pb2_grpc, ) from .logging import get_tracking_id_from_coro, log_request from .market_data_stream.async_market_data_stream_manager import ( AsyncMarketDataStreamManager, ) from .metadata import get_metadata from .schemas import ( AssetRequest, AssetResponse, AssetsRequest, AssetsResponse, BondResponse, BondsResponse, Brand, BrokerReportRequest, BrokerReportResponse, CancelOrderRequest, CancelOrderResponse, CancelStopOrderRequest, CancelStopOrderResponse, CandleInterval, CandleSource, CloseSandboxAccountRequest, CloseSandboxAccountResponse, CreateFavoriteGroupRequest, CreateFavoriteGroupResponse, CurrenciesResponse, CurrencyResponse, CurrencyTransferRequest, CurrencyTransferResponse, DeleteFavoriteGroupRequest, DeleteFavoriteGroupResponse, DfaResponse, DfasRequest, DfasResponse, EditFavoritesActionType, EditFavoritesRequest, EditFavoritesRequestInstrument, EditFavoritesResponse, EtfResponse, EtfsResponse, ExchangeOrderType, FilterOptionsRequest, FindInstrumentRequest, FindInstrumentResponse, FutureResponse, FuturesResponse, GenerateBrokerReportRequest, GenerateDividendsForeignIssuerReportRequest, GetAccountsRequest, GetAccountsResponse, GetAccountValuesRequest, GetAccountValuesResponse, GetAccruedInterestsRequest, GetAccruedInterestsResponse, GetAssetFundamentalsRequest, GetAssetFundamentalsResponse, GetAssetReportsRequest, GetAssetReportsResponse, GetBankAccountsRequest, GetBankAccountsResponse, GetBondCouponsRequest, GetBondCouponsResponse, GetBondEventsRequest, GetBondEventsResponse, GetBrandRequest, GetBrandsRequest, GetBrandsResponse, GetBrokerReportRequest, GetCandlesRequest, GetCandlesResponse, GetClosePricesRequest, GetClosePricesResponse, GetConsensusForecastsRequest, GetConsensusForecastsResponse, GetCountriesRequest, GetCountriesResponse, GetDividendsForeignIssuerReportRequest, GetDividendsForeignIssuerRequest, GetDividendsForeignIssuerResponse, GetDividendsRequest, GetDividendsResponse, GetFavoriteGroupsRequest, GetFavoriteGroupsResponse, GetFavoritesRequest, GetFavoritesResponse, GetForecastRequest, GetForecastResponse, GetFuturesMarginRequest, GetFuturesMarginResponse, GetInfoRequest, GetInfoResponse, GetInsiderDealsRequest, GetInsiderDealsResponse, GetLastPricesRequest, GetLastPricesResponse, GetLastTradesRequest, GetLastTradesResponse, GetMarginAttributesRequest, GetMarginAttributesResponse, GetMarketValuesRequest, GetMarketValuesResponse, GetMaxLotsRequest, GetMaxLotsResponse, GetOperationsByCursorRequest, GetOperationsByCursorResponse, GetOrderBookRequest, GetOrderBookResponse, GetOrderPriceRequest, GetOrderPriceResponse, GetOrdersRequest, GetOrdersRequestFilters, GetOrdersResponse, GetOrderStateRequest, GetSignalsRequest, GetSignalsResponse, GetStopOrdersRequest, GetStopOrdersResponse, GetStrategiesRequest, GetStrategiesResponse, GetTechAnalysisRequest, GetTechAnalysisResponse, GetTradingStatusesRequest, GetTradingStatusesResponse, GetTradingStatusRequest, GetTradingStatusResponse, GetUserTariffRequest, GetUserTariffResponse, HistoricCandle, IndicativesRequest, IndicativesResponse, InstrumentClosePriceRequest, InstrumentExchangeType, InstrumentIdType, InstrumentRequest, InstrumentResponse, InstrumentsRequest, InstrumentStatus, InstrumentType, LastPriceType, MarketDataRequest, MarketDataResponse, MarketDataServerSideStreamRequest, MoneyValue, OpenSandboxAccountRequest, OpenSandboxAccountResponse, OperationsRequest, OperationsResponse, OperationsStreamRequest, OperationsStreamResponse, OperationState, OptionResponse, OptionsResponse, OrderDirection, OrderExecutionReportStatus, OrderIdType, OrderState, OrderStateStreamRequest, OrderStateStreamResponse, OrderType, Page, PayInRequest, PayInResponse, PingDelaySettings, PortfolioRequest, PortfolioResponse, PortfolioStreamRequest, PortfolioStreamResponse, PositionsRequest, PositionsResponse, PositionsStreamRequest, PositionsStreamResponse, PostOrderAsyncRequest, PostOrderAsyncResponse, PostOrderRequest, PostOrderResponse, PostStopOrderRequest, PostStopOrderRequestTrailingData, PostStopOrderResponse, PriceType, Quotation, ReplaceOrderRequest, RiskRatesRequest, RiskRatesResponse, SandboxPayInRequest, SandboxPayInResponse, ShareResponse, SharesResponse, StopOrderDirection, StopOrderExpirationType, StopOrderStatusOption, StopOrderType, StructuredNoteResponse, StructuredNotesResponse, TakeProfitType, TimeInForceType, TradesStreamRequest, TradesStreamResponse, TradingSchedulesRequest, TradingSchedulesResponse, WithdrawLimitsRequest, WithdrawLimitsResponse, ) from .typedefs import AccountId from .utils import get_intervals, now __all__ = ( "AsyncServices", "InstrumentsService", "MarketDataService", "MarketDataStreamService", "OperationsService", "OperationsStreamService", "OrdersStreamService", "OrdersService", "UsersService", "SandboxService", "StopOrdersService", "SignalsService", ) class AsyncServices: def __init__( self, channel: grpc.aio.Channel, token: str, sandbox_token: Optional[str] = None, app_name: Optional[str] = None, ) -> None: metadata = get_metadata(token, app_name) sandbox_metadata = get_metadata(sandbox_token or token, app_name) self.instruments = InstrumentsService(channel, metadata) self.market_data = MarketDataService(channel, metadata) self.market_data_stream = MarketDataStreamService(channel, metadata) self.operations = OperationsService(channel, metadata) self.operations_stream = OperationsStreamService(channel, metadata) self.orders_stream = OrdersStreamService(channel, metadata) self.orders = OrdersService(channel, metadata) self.users = UsersService(channel, metadata) self.sandbox = SandboxService(channel, sandbox_metadata) self.stop_orders = StopOrdersService(channel, metadata) self.signals = SignalsService(channel, metadata) def create_market_data_stream(self) -> AsyncMarketDataStreamManager: return AsyncMarketDataStreamManager(market_data_stream=self.market_data_stream) async def cancel_all_orders(self, account_id: AccountId) -> None: orders_service: OrdersService = self.orders stop_orders_service: StopOrdersService = self.stop_orders orders_response = await orders_service.get_orders(account_id=account_id) await asyncio.gather( *[ orders_service.cancel_order( account_id=account_id, order_id=order.order_id ) for order in orders_response.orders ] ) stop_orders_response = await stop_orders_service.get_stop_orders( account_id=account_id ) await asyncio.gather( *[ stop_orders_service.cancel_stop_order( account_id=account_id, stop_order_id=stop_order.stop_order_id ) for stop_order in stop_orders_response.stop_orders ] ) async def get_all_candles( self, *, from_: datetime, to: Optional[datetime] = None, interval: CandleInterval = CandleInterval(0), figi: str = "", instrument_id: str = "", candle_source_type: Optional[CandleSource] = None, ) -> AsyncGenerator[HistoricCandle, None]: to = to or now() for local_from_, local_to in get_intervals(interval, from_, to): candles_response = await self.market_data.get_candles( figi=figi, interval=interval, from_=local_from_, to=local_to, instrument_id=instrument_id, candle_source_type=candle_source_type, ) for candle in candles_response.candles: yield candle class InstrumentsService(_grpc_helpers.Service): _stub_factory = instruments_pb2_grpc.InstrumentsServiceStub @handle_aio_request_error("TradingSchedules") async def trading_schedules( self, *, exchange: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, ) -> TradingSchedulesResponse: request = TradingSchedulesRequest() request.exchange = exchange if from_ is not None: request.from_ = from_ if to is not None: request.to = to response_coro = self.stub.TradingSchedules( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.TradingSchedulesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "TradingSchedules") return _grpc_helpers.protobuf_to_dataclass(response, TradingSchedulesResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("BondBy") async def bond_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> BondResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.BondBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "BondBy") return _grpc_helpers.protobuf_to_dataclass(response, BondResponse) @handle_aio_request_error("Bonds") async def bonds( self, *, instrument_status: InstrumentStatus = InstrumentStatus(0), instrument_exchange: InstrumentExchangeType = InstrumentExchangeType(0), ) -> BondsResponse: request = InstrumentsRequest() request.instrument_status = instrument_status request.instrument_exchange = instrument_exchange response_coro = self.stub.Bonds( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Bonds") return _grpc_helpers.protobuf_to_dataclass(response, BondsResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("CurrencyBy") async def currency_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> CurrencyResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.CurrencyBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "CurrencyBy") return _grpc_helpers.protobuf_to_dataclass(response, CurrencyResponse) @handle_aio_request_error("Currencies") async def currencies( self, *, instrument_status: InstrumentStatus = InstrumentStatus(0), instrument_exchange: InstrumentExchangeType = InstrumentExchangeType(0), ) -> CurrenciesResponse: request = InstrumentsRequest() request.instrument_status = instrument_status request.instrument_exchange = instrument_exchange response_coro = self.stub.Currencies( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Currencies") return _grpc_helpers.protobuf_to_dataclass(response, CurrenciesResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("EtfBy") async def etf_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> EtfResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.EtfBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "EtfBy") return _grpc_helpers.protobuf_to_dataclass(response, EtfResponse) @handle_aio_request_error("Etfs") async def etfs( self, *, instrument_status: InstrumentStatus = InstrumentStatus(0), instrument_exchange: InstrumentExchangeType = InstrumentExchangeType(0), ) -> EtfsResponse: request = InstrumentsRequest() request.instrument_status = instrument_status request.instrument_exchange = instrument_exchange response_coro = self.stub.Etfs( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Etfs") return _grpc_helpers.protobuf_to_dataclass(response, EtfsResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("FutureBy") async def future_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> FutureResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.FutureBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "FutureBy") return _grpc_helpers.protobuf_to_dataclass(response, FutureResponse) @handle_aio_request_error("Futures") async def futures( self, *, instrument_status: InstrumentStatus = InstrumentStatus(0), instrument_exchange: InstrumentExchangeType = InstrumentExchangeType(0), ) -> FuturesResponse: request = InstrumentsRequest() request.instrument_status = instrument_status request.instrument_exchange = instrument_exchange response_coro = self.stub.Futures( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Futures") return _grpc_helpers.protobuf_to_dataclass(response, FuturesResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("OptionBy") async def option_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> OptionResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.OptionBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "OptionBy") return _grpc_helpers.protobuf_to_dataclass(response, OptionResponse) @deprecated(details="Use `Client.instruments.options_by(...)` method instead") @handle_aio_request_error("Options") async def options( self, *, instrument_status: InstrumentStatus = InstrumentStatus(0) ) -> OptionsResponse: request = InstrumentsRequest() request.instrument_status = instrument_status response_coro = self.stub.Options( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Options") return _grpc_helpers.protobuf_to_dataclass(response, OptionsResponse) @handle_aio_request_error("OptionsBy") async def options_by( self, *, basic_asset_uid: str = "", basic_asset_position_uid: str = "" ) -> OptionsResponse: request = FilterOptionsRequest() request.basic_asset_uid = basic_asset_uid request.basic_asset_position_uid = basic_asset_position_uid response_coro = self.stub.OptionsBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.FilterOptionsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "OptionsBy") return _grpc_helpers.protobuf_to_dataclass(response, OptionsResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("ShareBy") async def share_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> ShareResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.ShareBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "ShareBy") return _grpc_helpers.protobuf_to_dataclass(response, ShareResponse) @handle_aio_request_error("Shares") async def shares( self, *, instrument_status: InstrumentStatus = InstrumentStatus(0), instrument_exchange: InstrumentExchangeType = InstrumentExchangeType(0), ) -> SharesResponse: request = InstrumentsRequest() request.instrument_status = instrument_status request.instrument_exchange = instrument_exchange response_coro = self.stub.Shares( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Shares") return _grpc_helpers.protobuf_to_dataclass(response, SharesResponse) @handle_aio_request_error("Indicatives") async def indicatives(self, request: IndicativesRequest) -> IndicativesResponse: response_coro = self.stub.Indicatives( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Indicatives") return _grpc_helpers.protobuf_to_dataclass(response, IndicativesResponse) @handle_aio_request_error("GetAccruedInterests") async def get_accrued_interests( self, *, figi: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, instrument_id: str = "", ) -> GetAccruedInterestsResponse: request = GetAccruedInterestsRequest() request.figi = figi request.instrument_id = instrument_id if from_ is not None: request.from_ = from_ if to is not None: request.to = to response_coro = self.stub.GetAccruedInterests( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetAccruedInterestsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetAccruedInterests" ) return _grpc_helpers.protobuf_to_dataclass( response, GetAccruedInterestsResponse ) @handle_aio_request_error("GetFuturesMargin") async def get_futures_margin( self, *, figi: str = "", instrument_id: str = "" ) -> GetFuturesMarginResponse: request = GetFuturesMarginRequest() request.figi = figi request.instrument_id = instrument_id response_coro = self.stub.GetFuturesMargin( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetFuturesMarginRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetFuturesMargin") return _grpc_helpers.protobuf_to_dataclass(response, GetFuturesMarginResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("GetInstrumentBy") async def get_instrument_by( self, *, id_type: InstrumentIdType = InstrumentIdType(0), class_code: str = "", id: str = "", ) -> InstrumentResponse: request = InstrumentRequest() request.id_type = id_type request.class_code = class_code request.id = id response_coro = self.stub.GetInstrumentBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetInstrumentBy") return _grpc_helpers.protobuf_to_dataclass(response, InstrumentResponse) @handle_aio_request_error("GetDividends") async def get_dividends( self, *, figi: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, instrument_id: str = "", ) -> GetDividendsResponse: request = GetDividendsRequest() request.figi = figi request.instrument_id = instrument_id if from_ is not None: request.from_ = from_ if to is not None: request.to = to response_coro = self.stub.GetDividends( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetDividendsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetDividends") return _grpc_helpers.protobuf_to_dataclass(response, GetDividendsResponse) @handle_aio_request_error("GetBondCoupons") async def get_bond_coupons( self, *, figi: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, instrument_id: str = "", ) -> GetBondCouponsResponse: request = GetBondCouponsRequest() request.figi = figi request.instrument_id = instrument_id if from_ is not None: request.from_ = from_ if to is not None: request.to = to response_coro = self.stub.GetBondCoupons( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetBondCouponsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetBondCoupons") return _grpc_helpers.protobuf_to_dataclass(response, GetBondCouponsResponse) @handle_aio_request_error("GetBondEvents") async def get_bond_events( self, request: GetBondEventsRequest ) -> GetBondEventsResponse: response_coro = self.stub.GetBondEvents( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetBondEventsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetBondEvents") return _grpc_helpers.protobuf_to_dataclass(response, GetBondEventsResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("GetAssetBy") async def get_asset_by( self, *, id: str = "", ) -> AssetResponse: request = AssetRequest() request.id = id response_coro = self.stub.GetAssetBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.AssetRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetAssetBy") return _grpc_helpers.protobuf_to_dataclass(response, AssetResponse) @handle_aio_request_error("GetAssets") async def get_assets( self, request: AssetsRequest, ) -> AssetsResponse: if request is None: request = AssetsRequest() response_coro = self.stub.GetAssets( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.AssetsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetAssets") return _grpc_helpers.protobuf_to_dataclass(response, AssetsResponse) @handle_aio_request_error("GetFavorites") async def get_favorites( self, *, group_id: Optional[str] = None, ) -> GetFavoritesResponse: request = GetFavoritesRequest() if group_id is not None: request.group_id = group_id response_coro = self.stub.GetFavorites( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetFavoritesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetFavorites") return _grpc_helpers.protobuf_to_dataclass(response, GetFavoritesResponse) @handle_aio_request_error("EditFavorites") async def edit_favorites( self, *, instruments: Optional[List[EditFavoritesRequestInstrument]] = None, action_type: Optional[EditFavoritesActionType] = None, group_id: Optional[str] = None, ) -> EditFavoritesResponse: request = EditFavoritesRequest() if action_type is not None: request.action_type = action_type if instruments is not None: request.instruments = instruments if group_id is not None: request.group_id = group_id response_coro = self.stub.EditFavorites( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.EditFavoritesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "EditFavorites") return _grpc_helpers.protobuf_to_dataclass(response, EditFavoritesResponse) @handle_aio_request_error("CreateFavoriteGroup") async def create_favorite_group( self, request: CreateFavoriteGroupRequest, ) -> CreateFavoriteGroupResponse: response_coro = self.stub.CreateFavoriteGroup( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.CreateFavoriteGroupRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "CreateFavoriteGroup" ) return _grpc_helpers.protobuf_to_dataclass( response, CreateFavoriteGroupResponse ) @handle_aio_request_error("DeleteFavoriteGroup") async def delete_favorite_group( self, request: DeleteFavoriteGroupRequest, ) -> DeleteFavoriteGroupResponse: response_coro = self.stub.DeleteFavoriteGroup( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.DeleteFavoriteGroupRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "DeleteFavoriteGroup" ) return _grpc_helpers.protobuf_to_dataclass( response, DeleteFavoriteGroupResponse ) @handle_aio_request_error("GetFavoriteGroups") async def get_favorite_groups( self, request: GetFavoriteGroupsRequest, ) -> GetFavoriteGroupsResponse: response_coro = self.stub.GetFavoriteGroups( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetFavoriteGroupsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetFavoriteGroups") return _grpc_helpers.protobuf_to_dataclass(response, GetFavoriteGroupsResponse) @handle_aio_request_error("GetCountries") async def get_countries( self, ) -> GetCountriesResponse: request = GetCountriesRequest() response_coro = self.stub.GetCountries( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetCountriesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetCountries") return _grpc_helpers.protobuf_to_dataclass(response, GetCountriesResponse) @handle_aio_request_error("FindInstrument") async def find_instrument( self, *, query: str = "", instrument_kind: Optional[InstrumentType] = None, api_trade_available_flag: Optional[bool] = None, ) -> FindInstrumentResponse: request = FindInstrumentRequest() request.query = query if instrument_kind is not None: request.instrument_kind = instrument_kind if api_trade_available_flag is not None: request.api_trade_available_flag = api_trade_available_flag response_coro = self.stub.FindInstrument( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.FindInstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "FindInstrument") return _grpc_helpers.protobuf_to_dataclass(response, FindInstrumentResponse) @handle_aio_request_error("GetBrands") async def get_brands( self, paging: Optional[Page] = None, ) -> GetBrandsResponse: request = GetBrandsRequest() if paging is not None: request.paging = paging response_coro = self.stub.GetBrands( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetBrandsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetBrands") return _grpc_helpers.protobuf_to_dataclass(response, GetBrandsResponse) # noinspection PyShadowingBuiltins @handle_aio_request_error("GetBrandBy") async def get_brands_by(self, id: str = "") -> Brand: request = GetBrandRequest() request.id = id response_coro = self.stub.GetBrandBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetBrandRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetBrandBy") return _grpc_helpers.protobuf_to_dataclass(response, Brand) @handle_aio_request_error("GetAssetFundamentals") async def get_asset_fundamentals( self, request: GetAssetFundamentalsRequest ) -> GetAssetFundamentalsResponse: response_coro = self.stub.GetAssetFundamentals( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetAssetFundamentalsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetAssetFundamentals" ) return _grpc_helpers.protobuf_to_dataclass( response, GetAssetFundamentalsResponse ) @handle_aio_request_error("GetAssetReports") async def get_asset_reports( self, request: GetAssetReportsRequest ) -> GetAssetReportsResponse: response_coro = self.stub.GetAssetReports( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetAssetReportsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetAssetReports") return _grpc_helpers.protobuf_to_dataclass(response, GetAssetReportsResponse) @handle_aio_request_error("GetConsensusForecasts") async def get_consensus_forecasts( self, request: GetConsensusForecastsRequest ) -> GetConsensusForecastsResponse: response_coro = self.stub.GetConsensusForecasts( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetConsensusForecastsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetConsensusForecasts" ) return _grpc_helpers.protobuf_to_dataclass( response, GetConsensusForecastsResponse ) @handle_aio_request_error("GetForecastBy") async def get_forecast_by(self, request: GetForecastRequest) -> GetForecastResponse: response_coro = self.stub.GetForecastBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetForecastRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetForecastBy") return _grpc_helpers.protobuf_to_dataclass(response, GetForecastResponse) @handle_aio_request_error("GetRiskRates") async def get_risk_rates(self, request: RiskRatesRequest) -> RiskRatesResponse: response_coro = self.stub.GetRiskRates( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.RiskRatesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetRiskRates") return _grpc_helpers.protobuf_to_dataclass(response, RiskRatesResponse) @handle_aio_request_error("GetInsiderDeals") async def get_insider_deals( self, request: GetInsiderDealsRequest ) -> GetInsiderDealsResponse: response_coro = self.stub.GetInsiderDeals( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.GetInsiderDealsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetInsiderDeals") return _grpc_helpers.protobuf_to_dataclass(response, GetInsiderDealsResponse) @handle_aio_request_error("StructuredNoteBy") async def get_structured_note_by( self, request: InstrumentRequest ) -> StructuredNoteResponse: response_coro = self.stub.StructuredNoteBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "StructuredNoteBy") return _grpc_helpers.protobuf_to_dataclass(response, StructuredNoteResponse) @handle_aio_request_error("StructuredNotes") async def get_structured_notes( self, request: InstrumentsRequest ) -> StructuredNotesResponse: response_coro = self.stub.StructuredNotes( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "StructuredNotes") return _grpc_helpers.protobuf_to_dataclass(response, StructuredNotesResponse) @handle_aio_request_error("Dfas") async def get_dfas(self) -> DfasResponse: request = DfasRequest() response_coro = self.stub.Dfas( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.DfasRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "Dfas") return _grpc_helpers.protobuf_to_dataclass(response, DfasResponse) @handle_aio_request_error("DfaBy") async def get_dfa_by(self, request: InstrumentRequest) -> DfaResponse: response_coro = self.stub.DfaBy( request=_grpc_helpers.dataclass_to_protobuff( request, instruments_pb2.InstrumentRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "DfaBy") return _grpc_helpers.protobuf_to_dataclass(response, DfaResponse) class MarketDataService(_grpc_helpers.Service): _stub_factory = marketdata_pb2_grpc.MarketDataServiceStub @handle_aio_request_error("GetCandles") async def get_candles( self, *, figi: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, interval: CandleInterval = CandleInterval(0), instrument_id: str = "", candle_source_type: Optional[CandleSource] = None, limit: Optional[int] = None, ) -> GetCandlesResponse: # noinspection DuplicatedCode request = GetCandlesRequest() request.figi = figi request.instrument_id = instrument_id request.candle_source_type = candle_source_type if from_ is not None: request.from_ = from_ if to is not None: request.to = to if limit is not None: request.limit = limit request.interval = interval response_coro = self.stub.GetCandles( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetCandlesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetCandles") return _grpc_helpers.protobuf_to_dataclass(response, GetCandlesResponse) @handle_aio_request_error("GetLastPrices") async def get_last_prices( self, *, figi: Optional[List[str]] = None, instrument_id: Optional[List[str]] = None, last_price_type: LastPriceType = LastPriceType.LAST_PRICE_UNSPECIFIED, instrument_status: Optional[InstrumentStatus] = None, ) -> GetLastPricesResponse: figi = figi or [] instrument_id = instrument_id or [] request = GetLastPricesRequest() request.figi = figi request.instrument_id = instrument_id request.last_price_type = last_price_type if instrument_status: request.instrument_status = instrument_status response_coro = self.stub.GetLastPrices( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetLastPricesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetLastPrices") return _grpc_helpers.protobuf_to_dataclass(response, GetLastPricesResponse) @handle_aio_request_error("GetOrderBook") async def get_order_book( self, *, figi: str = "", depth: int = 0, instrument_id: str = "" ) -> GetOrderBookResponse: request = GetOrderBookRequest() request.figi = figi request.instrument_id = instrument_id request.depth = depth response_coro = self.stub.GetOrderBook( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetOrderBookRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetOrderBook") return _grpc_helpers.protobuf_to_dataclass(response, GetOrderBookResponse) @handle_aio_request_error("GetTradingStatus") async def get_trading_status( self, *, figi: str = "", instrument_id: str = "" ) -> GetTradingStatusResponse: request = GetTradingStatusRequest() request.figi = figi request.instrument_id = instrument_id response_coro = self.stub.GetTradingStatus( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetTradingStatusRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetTradingStatus") return _grpc_helpers.protobuf_to_dataclass(response, GetTradingStatusResponse) @handle_aio_request_error("GetTradingStatuses") async def get_trading_statuses( self, *, instrument_ids: Optional[List[str]] = None ) -> GetTradingStatusesResponse: request = GetTradingStatusesRequest() if instrument_ids: request.instrument_id = instrument_ids response_coro = self.stub.GetTradingStatuses( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetTradingStatusesRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetTradingStatuses" ) return _grpc_helpers.protobuf_to_dataclass(response, GetTradingStatusesResponse) @handle_aio_request_error("GetLastTrades") async def get_last_trades( self, *, figi: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, instrument_id: str = "", ) -> GetLastTradesResponse: request = GetLastTradesRequest() request.figi = figi request.instrument_id = instrument_id if from_ is not None: request.from_ = from_ if to is not None: request.to = to response_coro = self.stub.GetLastTrades( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetLastTradesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetLastTrades") return _grpc_helpers.protobuf_to_dataclass(response, GetLastTradesResponse) @handle_aio_request_error("GetClosePrices") async def get_close_prices( self, *, instruments: Optional[List[InstrumentClosePriceRequest]] = None, instrument_status: Optional[InstrumentStatus] = None, ) -> GetClosePricesResponse: request = GetClosePricesRequest() if instruments: request.instruments = instruments if instrument_status: request.instrument_status = instrument_status response_coro = self.stub.GetClosePrices( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetClosePricesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetClosePrices") return _grpc_helpers.protobuf_to_dataclass(response, GetClosePricesResponse) @handle_aio_request_error("GetTechAnalysis") async def get_tech_analysis( self, *, request: GetTechAnalysisRequest, ) -> GetTechAnalysisResponse: response_coro = self.stub.GetTechAnalysis( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetTechAnalysisRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetTechAnalysis") return _grpc_helpers.protobuf_to_dataclass(response, GetTechAnalysisResponse) @handle_aio_request_error("GetMarketValues") async def get_market_values( self, *, request: GetMarketValuesRequest, ) -> GetMarketValuesResponse: response_coro = self.stub.GetMarketValues( request=_grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.GetMarketValuesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetMarketValues") return _grpc_helpers.protobuf_to_dataclass(response, GetMarketValuesResponse) class MarketDataStreamService(_grpc_helpers.Service): _stub_factory = marketdata_pb2_grpc.MarketDataStreamServiceStub @staticmethod async def _convert_market_data_stream_request( request_iterator: AsyncIterable[MarketDataRequest], ) -> AsyncIterable[marketdata_pb2.MarketDataRequest]: async for request in request_iterator: yield _grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.MarketDataRequest() ) @staticmethod async def _convert_market_data_server_side_stream_request( request_iterator: AsyncIterable[MarketDataServerSideStreamRequest], ) -> AsyncIterable[marketdata_pb2.MarketDataServerSideStreamRequest]: async for request in request_iterator: yield _grpc_helpers.dataclass_to_protobuff( request, marketdata_pb2.MarketDataServerSideStreamRequest() ) @handle_aio_error_hub_gen() @handle_aio_request_error_gen("MarketDataStream") async def market_data_stream( self, request_iterator: AsyncIterable[MarketDataRequest], ) -> AsyncIterable[MarketDataResponse]: async for response in self.stub.MarketDataStream( request_iterator=self._convert_market_data_stream_request(request_iterator), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass(response, MarketDataResponse) @handle_aio_error_hub_gen() @handle_aio_request_error_gen("MarketDataServerSideStream") async def market_data_server_side_stream( self, request_iterator: AsyncIterable[MarketDataServerSideStreamRequest], ) -> AsyncIterable[MarketDataResponse]: async for response in self.stub.MarketDataServerSideStream( request_iterator=self._convert_market_data_server_side_stream_request( request_iterator ), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass(response, MarketDataResponse) class OperationsService(_grpc_helpers.Service): _stub_factory = operations_pb2_grpc.OperationsServiceStub @handle_aio_request_error("GetOperations") async def get_operations( self, *, account_id: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, state: OperationState = OperationState(0), figi: str = "", ) -> OperationsResponse: request = OperationsRequest() request.account_id = account_id if from_ is not None: request.from_ = from_ if to is not None: request.to = to request.state = state request.figi = figi response_coro = self.stub.GetOperations( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.OperationsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetOperations") return _grpc_helpers.protobuf_to_dataclass(response, OperationsResponse) @handle_aio_request_error("GetPortfolio") async def get_portfolio(self, *, account_id: str = "") -> PortfolioResponse: request = PortfolioRequest() request.account_id = account_id response_coro = self.stub.GetPortfolio( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.PortfolioRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetPortfolio") return _grpc_helpers.protobuf_to_dataclass(response, PortfolioResponse) @handle_aio_request_error("GetPositions") async def get_positions(self, *, account_id: str = "") -> PositionsResponse: request = PositionsRequest() request.account_id = account_id response_coro = self.stub.GetPositions( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.PositionsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetPositions") return _grpc_helpers.protobuf_to_dataclass(response, PositionsResponse) @handle_aio_request_error("GetWithdrawLimits") async def get_withdraw_limits( self, *, account_id: str = "" ) -> WithdrawLimitsResponse: request = WithdrawLimitsRequest() request.account_id = account_id response_coro = self.stub.GetWithdrawLimits( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.WithdrawLimitsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetWithdrawLimits") return _grpc_helpers.protobuf_to_dataclass(response, WithdrawLimitsResponse) @handle_aio_request_error("GetBrokerReport") async def get_broker_report( self, *, generate_broker_report_request: Optional[GenerateBrokerReportRequest] = None, get_broker_report_request: Optional[GetBrokerReportRequest] = None, ) -> BrokerReportResponse: request = BrokerReportRequest() if generate_broker_report_request: request.generate_broker_report_request = generate_broker_report_request if get_broker_report_request: request.get_broker_report_request = get_broker_report_request response_coro = self.stub.GetBrokerReport( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.BrokerReportRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetBrokerReport") return _grpc_helpers.protobuf_to_dataclass(response, BrokerReportResponse) @handle_aio_request_error("GetDividendsForeignIssuer") async def get_dividends_foreign_issuer( self, *, generate_div_foreign_issuer_report: Optional[ GenerateDividendsForeignIssuerReportRequest ] = None, get_div_foreign_issuer_report: Optional[ GetDividendsForeignIssuerReportRequest ] = None, ) -> GetDividendsForeignIssuerResponse: request = GetDividendsForeignIssuerRequest() if generate_div_foreign_issuer_report is not None: request.generate_div_foreign_issuer_report = ( generate_div_foreign_issuer_report ) if get_div_foreign_issuer_report is not None: request.get_div_foreign_issuer_report = get_div_foreign_issuer_report response_coro = self.stub.GetDividendsForeignIssuer( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.GetDividendsForeignIssuerRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetDividendsForeignIssuer" ) return _grpc_helpers.protobuf_to_dataclass( response, GetDividendsForeignIssuerResponse ) @handle_aio_request_error("GetOperationsByCursor") async def get_operations_by_cursor( self, request: GetOperationsByCursorRequest, ) -> GetOperationsByCursorResponse: response_coro = self.stub.GetOperationsByCursor( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.GetOperationsByCursorRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetOperationsByCursor" ) return _grpc_helpers.protobuf_to_dataclass( response, GetOperationsByCursorResponse ) class OperationsStreamService(_grpc_helpers.Service): _stub_factory = operations_pb2_grpc.OperationsStreamServiceStub @handle_aio_error_hub_gen() @handle_aio_request_error_gen("PortfolioStream") async def portfolio_stream( self, *, accounts: Optional[List[str]] = None, ping_delay_ms: Optional[int] = None, ) -> AsyncIterable[PortfolioStreamResponse]: request = PortfolioStreamRequest() if accounts: request.accounts = accounts else: raise ValueError("accounts can not be empty") ping_settings = PingDelaySettings() if ping_delay_ms is not None: ping_settings.ping_delay_ms = ping_delay_ms request.ping_settings = ping_settings async for response in self.stub.PortfolioStream( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.PortfolioStreamRequest() ), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass(response, PortfolioStreamResponse) @handle_aio_error_hub_gen() @handle_aio_request_error_gen("PositionsStream") async def positions_stream( self, *, accounts: Optional[List[str]] = None, ping_delay_ms: Optional[int] = None, with_initial_positions: Optional[bool] = None, ) -> AsyncIterable[PositionsStreamResponse]: # noinspection DuplicatedCode request = PositionsStreamRequest() if accounts: request.accounts = accounts else: raise ValueError("accounts can not be empty") ping_settings = PingDelaySettings() if ping_delay_ms is not None: ping_settings.ping_delay_ms = ping_delay_ms request.ping_settings = ping_settings if with_initial_positions: request.with_initial_positions = with_initial_positions async for response in self.stub.PositionsStream( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.PositionsStreamRequest() ), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass(response, PositionsStreamResponse) @handle_aio_error_hub_gen() @handle_aio_request_error_gen("OperationsStream") async def operations_stream( self, request: OperationsStreamRequest, ) -> AsyncIterable[OperationsStreamResponse]: async for response in self.stub.OperationsStream( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.OperationsStreamRequest() ), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass( response, OperationsStreamResponse ) class OrdersStreamService(_grpc_helpers.Service): _stub_factory = orders_pb2_grpc.OrdersStreamServiceStub @handle_aio_error_hub_gen() @handle_aio_request_error_gen("TradesStream") async def trades_stream( self, *, accounts: Optional[List[str]] = None ) -> AsyncIterable[TradesStreamResponse]: request = TradesStreamRequest() if accounts: request.accounts = accounts else: raise ValueError("accounts can not be empty") async for response in self.stub.TradesStream( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.TradesStreamRequest() ), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass(response, TradesStreamResponse) @handle_aio_error_hub_gen() @handle_aio_request_error_gen("OrderStateStream") async def order_state_stream( self, *, request: OrderStateStreamRequest ) -> AsyncIterable[OrderStateStreamResponse]: async for response in self.stub.OrderStateStream( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.OrderStateStreamRequest() ), metadata=self.metadata, ): yield _grpc_helpers.protobuf_to_dataclass( response, OrderStateStreamResponse ) class OrdersService(_grpc_helpers.Service): _stub_factory = orders_pb2_grpc.OrdersServiceStub @handle_aio_request_error("PostOrder") async def post_order( self, *, figi: str = "", quantity: int = 0, price: Optional[Quotation] = None, direction: OrderDirection = OrderDirection(0), account_id: str = "", order_type: OrderType = OrderType(0), order_id: str = "", instrument_id: str = "", time_in_force: TimeInForceType = TimeInForceType(0), price_type: PriceType = PriceType(0), confirm_margin_trade: bool = False, ) -> PostOrderResponse: # noinspection DuplicatedCode request = PostOrderRequest() request.figi = figi request.instrument_id = instrument_id request.quantity = quantity if price is not None: request.price = price request.direction = direction request.account_id = account_id request.order_type = order_type if not utils.empty_or_uuid(order_id): raise RequestError( grpc.StatusCode.INVALID_ARGUMENT, "order_id should be empty or uuid", None, ) request.order_id = order_id request.time_in_force = time_in_force request.price_type = price_type if confirm_margin_trade: request.confirm_margin_trade = confirm_margin_trade response_coro = self.stub.PostOrder( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.PostOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "PostOrder") return _grpc_helpers.protobuf_to_dataclass(response, PostOrderResponse) @handle_aio_request_error("PostOrderAsync") async def post_order_async( self, request: PostOrderAsyncRequest ) -> PostOrderAsyncResponse: if not utils.empty_or_uuid(request.order_id): raise RequestError( grpc.StatusCode.INVALID_ARGUMENT, "order_id should be empty or uuid", None, ) response_coro = self.stub.PostOrderAsync( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.PostOrderAsyncRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "PostOrderAsync") return _grpc_helpers.protobuf_to_dataclass(response, PostOrderAsyncResponse) @handle_aio_request_error("CancelOrder") async def cancel_order( self, *, account_id: str = "", order_id: str = "", order_id_type: Optional["OrderIdType"] = None, ) -> CancelOrderResponse: request = CancelOrderRequest() request.account_id = account_id request.order_id = order_id request.order_id_type = order_id_type response_coro = self.stub.CancelOrder( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.CancelOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "CancelOrder") return _grpc_helpers.protobuf_to_dataclass(response, CancelOrderResponse) @handle_aio_request_error("GetOrderState") async def get_order_state( self, *, account_id: str = "", order_id: str = "", price_type: PriceType = PriceType(0), order_id_type: Optional["OrderIdType"] = None, ) -> OrderState: request = GetOrderStateRequest() request.account_id = account_id request.order_id = order_id request.price_type = price_type request.order_id_type = order_id_type response_coro = self.stub.GetOrderState( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetOrderStateRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetOrderState") return _grpc_helpers.protobuf_to_dataclass(response, OrderState) @handle_aio_request_error("GetOrders") async def get_orders( self, *, account_id: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, execution_status: Optional[List[OrderExecutionReportStatus]] = None, ) -> GetOrdersResponse: # noinspection DuplicatedCode request = GetOrdersRequest() request.account_id = account_id request.advanced_filters = GetOrdersRequestFilters() if from_ is not None: request.advanced_filters.from_ = from_ if to is not None: request.advanced_filters.to = to if execution_status is not None: request.advanced_filters.execution_status = execution_status response_coro = self.stub.GetOrders( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetOrdersRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetOrders") return _grpc_helpers.protobuf_to_dataclass(response, GetOrdersResponse) @handle_aio_request_error("ReplaceOrder") async def replace_order(self, request: ReplaceOrderRequest) -> PostOrderResponse: response_coro = self.stub.ReplaceOrder( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.ReplaceOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "ReplaceOrder") return _grpc_helpers.protobuf_to_dataclass(response, PostOrderResponse) @handle_aio_request_error("GetMaxLots") async def get_max_lots(self, request: GetMaxLotsRequest) -> GetMaxLotsResponse: response_coro = self.stub.GetMaxLots( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetMaxLotsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetMaxLots") return _grpc_helpers.protobuf_to_dataclass(response, GetMaxLotsResponse) @handle_aio_request_error("GetOrderPrice") async def get_order_price( self, request: GetOrderPriceRequest ) -> GetOrderPriceResponse: response_coro = self.stub.GetOrderPrice( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetOrderPriceRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetOrderPrice") return _grpc_helpers.protobuf_to_dataclass(response, GetOrderPriceResponse) class UsersService(_grpc_helpers.Service): _stub_factory = users_pb2_grpc.UsersServiceStub @handle_aio_request_error("GetAccounts") async def get_accounts(self) -> GetAccountsResponse: request = GetAccountsRequest() response_coro = self.stub.GetAccounts( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetAccountsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetAccounts") return _grpc_helpers.protobuf_to_dataclass(response, GetAccountsResponse) @handle_aio_request_error("GetMarginAttributes") async def get_margin_attributes( self, *, account_id: str = "" ) -> GetMarginAttributesResponse: request = GetMarginAttributesRequest() request.account_id = account_id response_coro = self.stub.GetMarginAttributes( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetMarginAttributesRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetMarginAttributes" ) return _grpc_helpers.protobuf_to_dataclass( response, GetMarginAttributesResponse ) @handle_aio_request_error("GetUserTariff") async def get_user_tariff(self) -> GetUserTariffResponse: request = GetUserTariffRequest() response_coro = self.stub.GetUserTariff( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetUserTariffRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetUserTariff") return _grpc_helpers.protobuf_to_dataclass(response, GetUserTariffResponse) @handle_aio_request_error("GetInfo") async def get_info(self) -> GetInfoResponse: request = GetInfoRequest() response_coro = self.stub.GetInfo( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetInfoRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetInfo") return _grpc_helpers.protobuf_to_dataclass(response, GetInfoResponse) @handle_aio_request_error("GetBankAccounts") async def get_bank_accounts(self) -> GetBankAccountsResponse: request = GetBankAccountsRequest() response_coro = self.stub.GetBankAccounts( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetBankAccountsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetBankAccounts") return _grpc_helpers.protobuf_to_dataclass(response, GetBankAccountsResponse) @handle_aio_request_error("CurrencyTransfer") async def currency_transfer( self, request: CurrencyTransferRequest ) -> CurrencyTransferResponse: response_coro = self.stub.CurrencyTransfer( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.CurrencyTransferRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "CurrencyTransfer") return _grpc_helpers.protobuf_to_dataclass(response, CurrencyTransferResponse) @handle_aio_request_error("PayIn") async def pay_in(self, request: PayInRequest) -> PayInResponse: response_coro = self.stub.PayIn( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.PayInRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "PayIn") return _grpc_helpers.protobuf_to_dataclass(response, PayInResponse) @handle_aio_request_error("GetAccountValues") async def get_account_values( self, request: GetAccountValuesRequest ) -> GetAccountValuesResponse: response_coro = self.stub.GetAccountValues( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetAccountValuesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetAccountValues") return _grpc_helpers.protobuf_to_dataclass(response, GetAccountValuesResponse) class SandboxService(_grpc_helpers.Service): _stub_factory = sandbox_pb2_grpc.SandboxServiceStub @handle_aio_request_error("OpenSandboxAccount") async def open_sandbox_account( self, name: Optional[str] = "" ) -> OpenSandboxAccountResponse: request = OpenSandboxAccountRequest() request.name = name response_coro = self.stub.OpenSandboxAccount( request=_grpc_helpers.dataclass_to_protobuff( request, sandbox_pb2.OpenSandboxAccountRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "OpenSandboxAccount" ) return _grpc_helpers.protobuf_to_dataclass(response, OpenSandboxAccountResponse) @handle_aio_request_error("GetSandboxAccounts") async def get_sandbox_accounts(self) -> GetAccountsResponse: request = GetAccountsRequest() response_coro = self.stub.GetSandboxAccounts( request=_grpc_helpers.dataclass_to_protobuff( request, users_pb2.GetAccountsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxAccounts" ) return _grpc_helpers.protobuf_to_dataclass(response, GetAccountsResponse) @handle_aio_request_error("CloseSandboxAccount") async def close_sandbox_account( self, *, account_id: str = "" ) -> CloseSandboxAccountResponse: request = CloseSandboxAccountRequest() request.account_id = account_id response_coro = self.stub.CloseSandboxAccount( request=_grpc_helpers.dataclass_to_protobuff( request, sandbox_pb2.CloseSandboxAccountRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "CloseSandboxAccount" ) return _grpc_helpers.protobuf_to_dataclass( response, CloseSandboxAccountResponse ) @handle_aio_request_error("PostSandboxOrder") async def post_sandbox_order( self, *, figi: str = "", quantity: int = 0, price: Optional[Quotation] = None, direction: OrderDirection = OrderDirection(0), account_id: str = "", order_type: OrderType = OrderType(0), order_id: str = "", instrument_id: str = "", time_in_force: TimeInForceType = TimeInForceType(0), price_type: PriceType = PriceType(0), ) -> PostOrderResponse: # noinspection DuplicatedCode request = PostOrderRequest() request.figi = figi request.instrument_id = instrument_id request.quantity = quantity if price is not None: request.price = price request.direction = direction request.account_id = account_id request.order_type = order_type if not utils.empty_or_uuid(order_id): raise RequestError( grpc.StatusCode.INVALID_ARGUMENT, "order_id should be empty or uuid", None, ) request.order_id = order_id request.time_in_force = time_in_force request.price_type = price_type response_coro = self.stub.PostSandboxOrder( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.PostOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "PostSandboxOrder") return _grpc_helpers.protobuf_to_dataclass(response, PostOrderResponse) @handle_aio_request_error("ReplaceSandboxOrder") async def replace_sandbox_order( self, request: "ReplaceOrderRequest", ) -> PostOrderResponse: response_coro = self.stub.ReplaceSandboxOrder( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.ReplaceOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "ReplaceSandboxOrder" ) return _grpc_helpers.protobuf_to_dataclass(response, PostOrderResponse) @handle_aio_request_error("GetSandboxOrders") async def get_sandbox_orders(self, *, account_id: str = "") -> GetOrdersResponse: request = GetOrdersRequest() request.account_id = account_id response_coro = self.stub.GetSandboxOrders( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetOrdersRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetSandboxOrders") return _grpc_helpers.protobuf_to_dataclass(response, GetOrdersResponse) @handle_aio_request_error("CancelSandboxOrder") async def cancel_sandbox_order( self, *, account_id: str = "", order_id: str = "", order_id_type: Optional["OrderIdType"] = None, ) -> CancelOrderResponse: request = CancelOrderRequest() request.account_id = account_id request.order_id = order_id request.order_id_type = order_id_type response_coro = self.stub.CancelSandboxOrder( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.CancelOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "CancelSandboxOrder" ) return _grpc_helpers.protobuf_to_dataclass(response, CancelOrderResponse) @handle_aio_request_error("GetSandboxOrderState") async def get_sandbox_order_state( self, *, account_id: str = "", order_id: str = "", price_type: PriceType = PriceType(0), order_id_type: Optional["OrderIdType"] = None, ) -> OrderState: request = GetOrderStateRequest() request.account_id = account_id request.order_id = order_id request.price_type = price_type request.order_id_type = order_id_type response_coro = self.stub.GetSandboxOrderState( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetOrderStateRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxOrderState" ) return _grpc_helpers.protobuf_to_dataclass(response, OrderState) @handle_aio_request_error("GetSandboxPositions") async def get_sandbox_positions(self, *, account_id: str = "") -> PositionsResponse: request = PositionsRequest() request.account_id = account_id response_coro = self.stub.GetSandboxPositions( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.PositionsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxPositions" ) return _grpc_helpers.protobuf_to_dataclass(response, PositionsResponse) @handle_aio_request_error("GetSandboxOperations") async def get_sandbox_operations( self, *, account_id: str = "", from_: Optional[datetime] = None, to: Optional[datetime] = None, state: OperationState = OperationState(0), figi: str = "", ) -> OperationsResponse: request = OperationsRequest() request.account_id = account_id if from_ is not None: request.from_ = from_ if to is not None: request.to = to request.state = state request.figi = figi response_coro = self.stub.GetSandboxOperations( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.OperationsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxOperations" ) return _grpc_helpers.protobuf_to_dataclass(response, OperationsResponse) @handle_aio_request_error("GetSandboxPortfolio") async def get_sandbox_portfolio(self, *, account_id: str = "") -> PortfolioResponse: request = PortfolioRequest() request.account_id = account_id response_coro = self.stub.GetSandboxPortfolio( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.PortfolioRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxPortfolio" ) return _grpc_helpers.protobuf_to_dataclass(response, PortfolioResponse) @handle_aio_request_error("SandboxPayIn") async def sandbox_pay_in( self, *, account_id: str = "", amount: Optional[MoneyValue] = None ) -> SandboxPayInResponse: request = SandboxPayInRequest() request.account_id = account_id if amount is not None: request.amount = amount response_coro = self.stub.SandboxPayIn( request=_grpc_helpers.dataclass_to_protobuff( request, sandbox_pb2.SandboxPayInRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "SandboxPayIn") return _grpc_helpers.protobuf_to_dataclass(response, SandboxPayInResponse) @handle_aio_request_error("GetSandboxWithdrawLimits") async def get_sandbox_withdraw_limits( self, *, account_id: str = "", ) -> WithdrawLimitsResponse: request = WithdrawLimitsRequest() request.account_id = account_id response_coro = self.stub.GetSandboxWithdrawLimits( request=_grpc_helpers.dataclass_to_protobuff( request, operations_pb2.WithdrawLimitsRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxWithdrawLimits" ) return _grpc_helpers.protobuf_to_dataclass(response, WithdrawLimitsResponse) @handle_aio_request_error("GetSandboxMaxLots") async def get_sandbox_max_lots( self, *, request: GetMaxLotsRequest, ) -> GetMaxLotsResponse: response_coro = self.stub.GetSandboxMaxLots( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetMaxLotsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetSandboxMaxLots") return _grpc_helpers.protobuf_to_dataclass(response, GetMaxLotsResponse) @handle_aio_request_error("PostSandboxOrderAsync") async def post_sandbox_order_async( self, *, request: "PostOrderAsyncRequest", ) -> PostOrderAsyncResponse: response_coro = self.stub.PostSandboxOrderAsync( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.PostOrderAsyncRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "PostSandboxOrderAsync" ) return _grpc_helpers.protobuf_to_dataclass(response, PostOrderAsyncResponse) @handle_aio_request_error("PostSandboxStopOrder") async def post_sandbox_stop_order( self, *, request: "PostStopOrderRequest" ) -> PostStopOrderResponse: response_coro = self.stub.PostSandboxStopOrder( request=_grpc_helpers.dataclass_to_protobuff( request, stoporders_pb2.PostStopOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "PostSandboxStopOrder" ) return _grpc_helpers.protobuf_to_dataclass(response, PostStopOrderResponse) @handle_aio_request_error("GetSandboxStopOrders") async def get_sandbox_stop_orders( self, *, request: "GetStopOrdersRequest" ) -> GetStopOrdersResponse: response_coro = self.stub.GetSandboxStopOrders( request=_grpc_helpers.dataclass_to_protobuff( request, stoporders_pb2.GetStopOrdersRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxStopOrders" ) return _grpc_helpers.protobuf_to_dataclass(response, GetStopOrdersResponse) @handle_aio_request_error("CancelSandboxStopOrder") async def cancel_sandbox_stop_order( self, *, request: "CancelStopOrderRequest" ) -> CancelStopOrderResponse: response_coro = self.stub.CancelSandboxStopOrder( request=_grpc_helpers.dataclass_to_protobuff( request, stoporders_pb2.CancelStopOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "CancelSandboxStopOrder" ) return _grpc_helpers.protobuf_to_dataclass(response, CancelStopOrderResponse) @handle_aio_request_error("GetSandboxOrderPrice") async def get_sandbox_order_price( self, request: GetOrderPriceRequest ) -> GetOrderPriceResponse: response_coro = self.stub.GetSandboxOrderPrice( request=_grpc_helpers.dataclass_to_protobuff( request, orders_pb2.GetOrderPriceRequest() ), metadata=self.metadata, ) response = await response_coro log_request( await get_tracking_id_from_coro(response_coro), "GetSandboxOrderPrice" ) return _grpc_helpers.protobuf_to_dataclass(response, GetOrderPriceResponse) class StopOrdersService(_grpc_helpers.Service): _stub_factory = stoporders_pb2_grpc.StopOrdersServiceStub @handle_aio_request_error("PostStopOrder") async def post_stop_order( self, *, figi: str = "", quantity: int = 0, price: Optional[Quotation] = None, stop_price: Optional[Quotation] = None, direction: StopOrderDirection = StopOrderDirection(0), account_id: str = "", expiration_type: StopOrderExpirationType = StopOrderExpirationType(0), stop_order_type: StopOrderType = StopOrderType(0), expire_date: Optional[datetime] = None, instrument_id: str = "", exchange_order_type: ExchangeOrderType = ExchangeOrderType(0), take_profit_type: TakeProfitType = TakeProfitType(0), trailing_data: Optional[PostStopOrderRequestTrailingData] = None, price_type: PriceType = PriceType(0), order_id: str = "", confirm_margin_trade: bool = False, instant_execution: Optional[bool] = None, ) -> PostStopOrderResponse: # noinspection DuplicatedCode request = PostStopOrderRequest() request.figi = figi request.instrument_id = instrument_id request.quantity = quantity if price is not None: request.price = price if stop_price is not None: request.stop_price = stop_price request.direction = direction request.account_id = account_id request.expiration_type = expiration_type request.stop_order_type = stop_order_type if expire_date is not None: request.expire_date = expire_date request.exchange_order_type = exchange_order_type request.take_profit_type = take_profit_type if trailing_data is not None: request.trailing_data = trailing_data request.price_type = price_type request.order_id = order_id if confirm_margin_trade: request.confirm_margin_trade = confirm_margin_trade if instant_execution is not None: request.instant_execution = instant_execution response_coro = self.stub.PostStopOrder( request=_grpc_helpers.dataclass_to_protobuff( request, stoporders_pb2.PostStopOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "PostStopOrder") return _grpc_helpers.protobuf_to_dataclass(response, PostStopOrderResponse) @handle_aio_request_error("GetStopOrders") async def get_stop_orders( self, *, account_id: str = "", status: StopOrderStatusOption = StopOrderStatusOption(0), from_: Optional[datetime] = None, to: Optional[datetime] = None, ) -> GetStopOrdersResponse: request = GetStopOrdersRequest() request.account_id = account_id request.status = status if from_ is not None: request.from_ = from_ if to is not None: request.to = to response_coro = self.stub.GetStopOrders( request=_grpc_helpers.dataclass_to_protobuff( request, stoporders_pb2.GetStopOrdersRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetStopOrders") return _grpc_helpers.protobuf_to_dataclass(response, GetStopOrdersResponse) @handle_aio_request_error("CancelStopOrder") async def cancel_stop_order( self, *, account_id: str = "", stop_order_id: str = "" ) -> CancelStopOrderResponse: request = CancelStopOrderRequest() request.account_id = account_id request.stop_order_id = stop_order_id response_coro = self.stub.CancelStopOrder( request=_grpc_helpers.dataclass_to_protobuff( request, stoporders_pb2.CancelStopOrderRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "CancelStopOrder") return _grpc_helpers.protobuf_to_dataclass(response, CancelStopOrderResponse) class SignalsService(_grpc_helpers.Service): _stub_factory = signals_pb2_grpc.SignalServiceStub @handle_aio_request_error("GetSignals") async def get_signals( self, *, request: GetSignalsRequest, ) -> GetSignalsResponse: response_coro = self.stub.GetSignals( request=_grpc_helpers.dataclass_to_protobuff( request, signals_pb2.GetSignalsRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetSignals") return _grpc_helpers.protobuf_to_dataclass(response, GetSignalsResponse) @handle_aio_request_error("GetStrategies") async def get_strategies( self, *, request: GetStrategiesRequest, ) -> GetStrategiesResponse: response_coro = self.stub.GetStrategies( request=_grpc_helpers.dataclass_to_protobuff( request, signals_pb2.GetStrategiesRequest() ), metadata=self.metadata, ) response = await response_coro log_request(await get_tracking_id_from_coro(response_coro), "GetStrategies") return _grpc_helpers.protobuf_to_dataclass(response, GetStrategiesResponse)