# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc

from . import trading_pb2 as api_dot_trading__pb2


class TradingServiceStub(object):
    """Missing associated documentation comment in .proto file."""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.PrepareSubmitOrder = channel.unary_unary(
                '/api.v1.TradingService/PrepareSubmitOrder',
                request_serializer=api_dot_trading__pb2.PrepareSubmitOrderRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareSubmitOrderResponse.FromString,
                )
        self.PrepareCancelOrder = channel.unary_unary(
                '/api.v1.TradingService/PrepareCancelOrder',
                request_serializer=api_dot_trading__pb2.PrepareCancelOrderRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareCancelOrderResponse.FromString,
                )
        self.PrepareAmendOrder = channel.unary_unary(
                '/api.v1.TradingService/PrepareAmendOrder',
                request_serializer=api_dot_trading__pb2.PrepareAmendOrderRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareAmendOrderResponse.FromString,
                )
        self.PrepareWithdraw = channel.unary_unary(
                '/api.v1.TradingService/PrepareWithdraw',
                request_serializer=api_dot_trading__pb2.PrepareWithdrawRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareWithdrawResponse.FromString,
                )
        self.SubmitTransaction = channel.unary_unary(
                '/api.v1.TradingService/SubmitTransaction',
                request_serializer=api_dot_trading__pb2.SubmitTransactionRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.SubmitTransactionResponse.FromString,
                )
        self.PrepareProposal = channel.unary_unary(
                '/api.v1.TradingService/PrepareProposal',
                request_serializer=api_dot_trading__pb2.PrepareProposalRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareProposalResponse.FromString,
                )
        self.PrepareVote = channel.unary_unary(
                '/api.v1.TradingService/PrepareVote',
                request_serializer=api_dot_trading__pb2.PrepareVoteRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareVoteResponse.FromString,
                )
        self.PropagateChainEvent = channel.unary_unary(
                '/api.v1.TradingService/PropagateChainEvent',
                request_serializer=api_dot_trading__pb2.PropagateChainEventRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PropagateChainEventResponse.FromString,
                )
        self.PrepareLiquidityProvision = channel.unary_unary(
                '/api.v1.TradingService/PrepareLiquidityProvision',
                request_serializer=api_dot_trading__pb2.PrepareLiquidityProvisionRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PrepareLiquidityProvisionResponse.FromString,
                )


class TradingServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def PrepareSubmitOrder(self, request, context):
        """Prepare a submit order request
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareCancelOrder(self, request, context):
        """Prepare a cancel order request
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareAmendOrder(self, request, context):
        """Prepare an amend order request
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareWithdraw(self, request, context):
        """Request a withdrawal
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubmitTransaction(self, request, context):
        """Submit a signed transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareProposal(self, request, context):
        """Prepare a governance proposal
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareVote(self, request, context):
        """Prepare a governance vote
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PropagateChainEvent(self, request, context):
        """Propagate a chain event
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareLiquidityProvision(self, request, context):
        """Prepare a liquidity provision request
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TradingServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'PrepareSubmitOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareSubmitOrder,
                    request_deserializer=api_dot_trading__pb2.PrepareSubmitOrderRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareSubmitOrderResponse.SerializeToString,
            ),
            'PrepareCancelOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareCancelOrder,
                    request_deserializer=api_dot_trading__pb2.PrepareCancelOrderRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareCancelOrderResponse.SerializeToString,
            ),
            'PrepareAmendOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareAmendOrder,
                    request_deserializer=api_dot_trading__pb2.PrepareAmendOrderRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareAmendOrderResponse.SerializeToString,
            ),
            'PrepareWithdraw': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareWithdraw,
                    request_deserializer=api_dot_trading__pb2.PrepareWithdrawRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareWithdrawResponse.SerializeToString,
            ),
            'SubmitTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.SubmitTransaction,
                    request_deserializer=api_dot_trading__pb2.SubmitTransactionRequest.FromString,
                    response_serializer=api_dot_trading__pb2.SubmitTransactionResponse.SerializeToString,
            ),
            'PrepareProposal': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareProposal,
                    request_deserializer=api_dot_trading__pb2.PrepareProposalRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareProposalResponse.SerializeToString,
            ),
            'PrepareVote': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareVote,
                    request_deserializer=api_dot_trading__pb2.PrepareVoteRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareVoteResponse.SerializeToString,
            ),
            'PropagateChainEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.PropagateChainEvent,
                    request_deserializer=api_dot_trading__pb2.PropagateChainEventRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PropagateChainEventResponse.SerializeToString,
            ),
            'PrepareLiquidityProvision': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareLiquidityProvision,
                    request_deserializer=api_dot_trading__pb2.PrepareLiquidityProvisionRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PrepareLiquidityProvisionResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'api.v1.TradingService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class TradingService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def PrepareSubmitOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareSubmitOrder',
            api_dot_trading__pb2.PrepareSubmitOrderRequest.SerializeToString,
            api_dot_trading__pb2.PrepareSubmitOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareCancelOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareCancelOrder',
            api_dot_trading__pb2.PrepareCancelOrderRequest.SerializeToString,
            api_dot_trading__pb2.PrepareCancelOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareAmendOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareAmendOrder',
            api_dot_trading__pb2.PrepareAmendOrderRequest.SerializeToString,
            api_dot_trading__pb2.PrepareAmendOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareWithdraw(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareWithdraw',
            api_dot_trading__pb2.PrepareWithdrawRequest.SerializeToString,
            api_dot_trading__pb2.PrepareWithdrawResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SubmitTransaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/SubmitTransaction',
            api_dot_trading__pb2.SubmitTransactionRequest.SerializeToString,
            api_dot_trading__pb2.SubmitTransactionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareProposal(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareProposal',
            api_dot_trading__pb2.PrepareProposalRequest.SerializeToString,
            api_dot_trading__pb2.PrepareProposalResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareVote(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareVote',
            api_dot_trading__pb2.PrepareVoteRequest.SerializeToString,
            api_dot_trading__pb2.PrepareVoteResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PropagateChainEvent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PropagateChainEvent',
            api_dot_trading__pb2.PropagateChainEventRequest.SerializeToString,
            api_dot_trading__pb2.PropagateChainEventResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareLiquidityProvision(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingService/PrepareLiquidityProvision',
            api_dot_trading__pb2.PrepareLiquidityProvisionRequest.SerializeToString,
            api_dot_trading__pb2.PrepareLiquidityProvisionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class TradingDataServiceStub(object):
    """Missing associated documentation comment in .proto file."""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.MarketAccounts = channel.unary_unary(
                '/api.v1.TradingDataService/MarketAccounts',
                request_serializer=api_dot_trading__pb2.MarketAccountsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketAccountsResponse.FromString,
                )
        self.PartyAccounts = channel.unary_unary(
                '/api.v1.TradingDataService/PartyAccounts',
                request_serializer=api_dot_trading__pb2.PartyAccountsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PartyAccountsResponse.FromString,
                )
        self.FeeInfrastructureAccounts = channel.unary_unary(
                '/api.v1.TradingDataService/FeeInfrastructureAccounts',
                request_serializer=api_dot_trading__pb2.FeeInfrastructureAccountsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.FeeInfrastructureAccountsResponse.FromString,
                )
        self.Candles = channel.unary_unary(
                '/api.v1.TradingDataService/Candles',
                request_serializer=api_dot_trading__pb2.CandlesRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.CandlesResponse.FromString,
                )
        self.MarketDataByID = channel.unary_unary(
                '/api.v1.TradingDataService/MarketDataByID',
                request_serializer=api_dot_trading__pb2.MarketDataByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketDataByIDResponse.FromString,
                )
        self.MarketsData = channel.unary_unary(
                '/api.v1.TradingDataService/MarketsData',
                request_serializer=api_dot_trading__pb2.MarketsDataRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketsDataResponse.FromString,
                )
        self.MarketByID = channel.unary_unary(
                '/api.v1.TradingDataService/MarketByID',
                request_serializer=api_dot_trading__pb2.MarketByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketByIDResponse.FromString,
                )
        self.MarketDepth = channel.unary_unary(
                '/api.v1.TradingDataService/MarketDepth',
                request_serializer=api_dot_trading__pb2.MarketDepthRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketDepthResponse.FromString,
                )
        self.Markets = channel.unary_unary(
                '/api.v1.TradingDataService/Markets',
                request_serializer=api_dot_trading__pb2.MarketsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketsResponse.FromString,
                )
        self.OrderByMarketAndID = channel.unary_unary(
                '/api.v1.TradingDataService/OrderByMarketAndID',
                request_serializer=api_dot_trading__pb2.OrderByMarketAndIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrderByMarketAndIDResponse.FromString,
                )
        self.OrderByReference = channel.unary_unary(
                '/api.v1.TradingDataService/OrderByReference',
                request_serializer=api_dot_trading__pb2.OrderByReferenceRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrderByReferenceResponse.FromString,
                )
        self.OrdersByMarket = channel.unary_unary(
                '/api.v1.TradingDataService/OrdersByMarket',
                request_serializer=api_dot_trading__pb2.OrdersByMarketRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrdersByMarketResponse.FromString,
                )
        self.OrdersByParty = channel.unary_unary(
                '/api.v1.TradingDataService/OrdersByParty',
                request_serializer=api_dot_trading__pb2.OrdersByPartyRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrdersByPartyResponse.FromString,
                )
        self.OrderByID = channel.unary_unary(
                '/api.v1.TradingDataService/OrderByID',
                request_serializer=api_dot_trading__pb2.OrderByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrderByIDResponse.FromString,
                )
        self.OrderVersionsByID = channel.unary_unary(
                '/api.v1.TradingDataService/OrderVersionsByID',
                request_serializer=api_dot_trading__pb2.OrderVersionsByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrderVersionsByIDResponse.FromString,
                )
        self.MarginLevels = channel.unary_unary(
                '/api.v1.TradingDataService/MarginLevels',
                request_serializer=api_dot_trading__pb2.MarginLevelsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarginLevelsResponse.FromString,
                )
        self.Parties = channel.unary_unary(
                '/api.v1.TradingDataService/Parties',
                request_serializer=api_dot_trading__pb2.PartiesRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PartiesResponse.FromString,
                )
        self.PartyByID = channel.unary_unary(
                '/api.v1.TradingDataService/PartyByID',
                request_serializer=api_dot_trading__pb2.PartyByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PartyByIDResponse.FromString,
                )
        self.PositionsByParty = channel.unary_unary(
                '/api.v1.TradingDataService/PositionsByParty',
                request_serializer=api_dot_trading__pb2.PositionsByPartyRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PositionsByPartyResponse.FromString,
                )
        self.LastTrade = channel.unary_unary(
                '/api.v1.TradingDataService/LastTrade',
                request_serializer=api_dot_trading__pb2.LastTradeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.LastTradeResponse.FromString,
                )
        self.TradesByMarket = channel.unary_unary(
                '/api.v1.TradingDataService/TradesByMarket',
                request_serializer=api_dot_trading__pb2.TradesByMarketRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.TradesByMarketResponse.FromString,
                )
        self.TradesByOrder = channel.unary_unary(
                '/api.v1.TradingDataService/TradesByOrder',
                request_serializer=api_dot_trading__pb2.TradesByOrderRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.TradesByOrderResponse.FromString,
                )
        self.TradesByParty = channel.unary_unary(
                '/api.v1.TradingDataService/TradesByParty',
                request_serializer=api_dot_trading__pb2.TradesByPartyRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.TradesByPartyResponse.FromString,
                )
        self.GetProposals = channel.unary_unary(
                '/api.v1.TradingDataService/GetProposals',
                request_serializer=api_dot_trading__pb2.GetProposalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetProposalsResponse.FromString,
                )
        self.GetProposalsByParty = channel.unary_unary(
                '/api.v1.TradingDataService/GetProposalsByParty',
                request_serializer=api_dot_trading__pb2.GetProposalsByPartyRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetProposalsByPartyResponse.FromString,
                )
        self.GetVotesByParty = channel.unary_unary(
                '/api.v1.TradingDataService/GetVotesByParty',
                request_serializer=api_dot_trading__pb2.GetVotesByPartyRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetVotesByPartyResponse.FromString,
                )
        self.GetNewMarketProposals = channel.unary_unary(
                '/api.v1.TradingDataService/GetNewMarketProposals',
                request_serializer=api_dot_trading__pb2.GetNewMarketProposalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetNewMarketProposalsResponse.FromString,
                )
        self.GetUpdateMarketProposals = channel.unary_unary(
                '/api.v1.TradingDataService/GetUpdateMarketProposals',
                request_serializer=api_dot_trading__pb2.GetUpdateMarketProposalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetUpdateMarketProposalsResponse.FromString,
                )
        self.GetNetworkParametersProposals = channel.unary_unary(
                '/api.v1.TradingDataService/GetNetworkParametersProposals',
                request_serializer=api_dot_trading__pb2.GetNetworkParametersProposalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetNetworkParametersProposalsResponse.FromString,
                )
        self.GetNewAssetProposals = channel.unary_unary(
                '/api.v1.TradingDataService/GetNewAssetProposals',
                request_serializer=api_dot_trading__pb2.GetNewAssetProposalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetNewAssetProposalsResponse.FromString,
                )
        self.GetProposalByID = channel.unary_unary(
                '/api.v1.TradingDataService/GetProposalByID',
                request_serializer=api_dot_trading__pb2.GetProposalByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetProposalByIDResponse.FromString,
                )
        self.GetProposalByReference = channel.unary_unary(
                '/api.v1.TradingDataService/GetProposalByReference',
                request_serializer=api_dot_trading__pb2.GetProposalByReferenceRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetProposalByReferenceResponse.FromString,
                )
        self.ObserveGovernance = channel.unary_stream(
                '/api.v1.TradingDataService/ObserveGovernance',
                request_serializer=api_dot_trading__pb2.ObserveGovernanceRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.ObserveGovernanceResponse.FromString,
                )
        self.ObservePartyProposals = channel.unary_stream(
                '/api.v1.TradingDataService/ObservePartyProposals',
                request_serializer=api_dot_trading__pb2.ObservePartyProposalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.ObservePartyProposalsResponse.FromString,
                )
        self.ObservePartyVotes = channel.unary_stream(
                '/api.v1.TradingDataService/ObservePartyVotes',
                request_serializer=api_dot_trading__pb2.ObservePartyVotesRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.ObservePartyVotesResponse.FromString,
                )
        self.ObserveProposalVotes = channel.unary_stream(
                '/api.v1.TradingDataService/ObserveProposalVotes',
                request_serializer=api_dot_trading__pb2.ObserveProposalVotesRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.ObserveProposalVotesResponse.FromString,
                )
        self.ObserveEventBus = channel.stream_stream(
                '/api.v1.TradingDataService/ObserveEventBus',
                request_serializer=api_dot_trading__pb2.ObserveEventBusRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.ObserveEventBusResponse.FromString,
                )
        self.Statistics = channel.unary_unary(
                '/api.v1.TradingDataService/Statistics',
                request_serializer=api_dot_trading__pb2.StatisticsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.StatisticsResponse.FromString,
                )
        self.GetVegaTime = channel.unary_unary(
                '/api.v1.TradingDataService/GetVegaTime',
                request_serializer=api_dot_trading__pb2.GetVegaTimeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetVegaTimeResponse.FromString,
                )
        self.AccountsSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/AccountsSubscribe',
                request_serializer=api_dot_trading__pb2.AccountsSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.AccountsSubscribeResponse.FromString,
                )
        self.CandlesSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/CandlesSubscribe',
                request_serializer=api_dot_trading__pb2.CandlesSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.CandlesSubscribeResponse.FromString,
                )
        self.MarginLevelsSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/MarginLevelsSubscribe',
                request_serializer=api_dot_trading__pb2.MarginLevelsSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarginLevelsSubscribeResponse.FromString,
                )
        self.MarketDepthSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/MarketDepthSubscribe',
                request_serializer=api_dot_trading__pb2.MarketDepthSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketDepthSubscribeResponse.FromString,
                )
        self.MarketDepthUpdatesSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/MarketDepthUpdatesSubscribe',
                request_serializer=api_dot_trading__pb2.MarketDepthUpdatesSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketDepthUpdatesSubscribeResponse.FromString,
                )
        self.MarketsDataSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/MarketsDataSubscribe',
                request_serializer=api_dot_trading__pb2.MarketsDataSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.MarketsDataSubscribeResponse.FromString,
                )
        self.OrdersSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/OrdersSubscribe',
                request_serializer=api_dot_trading__pb2.OrdersSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OrdersSubscribeResponse.FromString,
                )
        self.PositionsSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/PositionsSubscribe',
                request_serializer=api_dot_trading__pb2.PositionsSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.PositionsSubscribeResponse.FromString,
                )
        self.TradesSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/TradesSubscribe',
                request_serializer=api_dot_trading__pb2.TradesSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.TradesSubscribeResponse.FromString,
                )
        self.TransferResponsesSubscribe = channel.unary_stream(
                '/api.v1.TradingDataService/TransferResponsesSubscribe',
                request_serializer=api_dot_trading__pb2.TransferResponsesSubscribeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.TransferResponsesSubscribeResponse.FromString,
                )
        self.GetNodeSignaturesAggregate = channel.unary_unary(
                '/api.v1.TradingDataService/GetNodeSignaturesAggregate',
                request_serializer=api_dot_trading__pb2.GetNodeSignaturesAggregateRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.GetNodeSignaturesAggregateResponse.FromString,
                )
        self.AssetByID = channel.unary_unary(
                '/api.v1.TradingDataService/AssetByID',
                request_serializer=api_dot_trading__pb2.AssetByIDRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.AssetByIDResponse.FromString,
                )
        self.Assets = channel.unary_unary(
                '/api.v1.TradingDataService/Assets',
                request_serializer=api_dot_trading__pb2.AssetsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.AssetsResponse.FromString,
                )
        self.EstimateFee = channel.unary_unary(
                '/api.v1.TradingDataService/EstimateFee',
                request_serializer=api_dot_trading__pb2.EstimateFeeRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.EstimateFeeResponse.FromString,
                )
        self.EstimateMargin = channel.unary_unary(
                '/api.v1.TradingDataService/EstimateMargin',
                request_serializer=api_dot_trading__pb2.EstimateMarginRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.EstimateMarginResponse.FromString,
                )
        self.ERC20WithdrawalApproval = channel.unary_unary(
                '/api.v1.TradingDataService/ERC20WithdrawalApproval',
                request_serializer=api_dot_trading__pb2.ERC20WithdrawalApprovalRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.ERC20WithdrawalApprovalResponse.FromString,
                )
        self.Withdrawal = channel.unary_unary(
                '/api.v1.TradingDataService/Withdrawal',
                request_serializer=api_dot_trading__pb2.WithdrawalRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.WithdrawalResponse.FromString,
                )
        self.Withdrawals = channel.unary_unary(
                '/api.v1.TradingDataService/Withdrawals',
                request_serializer=api_dot_trading__pb2.WithdrawalsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.WithdrawalsResponse.FromString,
                )
        self.Deposit = channel.unary_unary(
                '/api.v1.TradingDataService/Deposit',
                request_serializer=api_dot_trading__pb2.DepositRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.DepositResponse.FromString,
                )
        self.Deposits = channel.unary_unary(
                '/api.v1.TradingDataService/Deposits',
                request_serializer=api_dot_trading__pb2.DepositsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.DepositsResponse.FromString,
                )
        self.NetworkParameters = channel.unary_unary(
                '/api.v1.TradingDataService/NetworkParameters',
                request_serializer=api_dot_trading__pb2.NetworkParametersRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.NetworkParametersResponse.FromString,
                )
        self.LiquidityProvisions = channel.unary_unary(
                '/api.v1.TradingDataService/LiquidityProvisions',
                request_serializer=api_dot_trading__pb2.LiquidityProvisionsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.LiquidityProvisionsResponse.FromString,
                )
        self.OracleSpec = channel.unary_unary(
                '/api.v1.TradingDataService/OracleSpec',
                request_serializer=api_dot_trading__pb2.OracleSpecRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OracleSpecResponse.FromString,
                )
        self.OracleSpecs = channel.unary_unary(
                '/api.v1.TradingDataService/OracleSpecs',
                request_serializer=api_dot_trading__pb2.OracleSpecsRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OracleSpecsResponse.FromString,
                )
        self.OracleDataBySpec = channel.unary_unary(
                '/api.v1.TradingDataService/OracleDataBySpec',
                request_serializer=api_dot_trading__pb2.OracleDataBySpecRequest.SerializeToString,
                response_deserializer=api_dot_trading__pb2.OracleDataBySpecResponse.FromString,
                )


class TradingDataServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def MarketAccounts(self, request, context):
        """-- Accounts --

        Get a list of Accounts by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PartyAccounts(self, request, context):
        """Get a list of Accounts by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FeeInfrastructureAccounts(self, request, context):
        """Get a list of accounts holding infrastructure fees.
        Can be filtered by asset, there will be 1 infrastructure fee account per
        asset in the network.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Candles(self, request, context):
        """-- Candles --

        Get a list of Candles by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDataByID(self, request, context):
        """-- Market Data --

        Get Market Data by Market ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketsData(self, request, context):
        """Get a list of Market Data
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketByID(self, request, context):
        """-- Markets --

        Get a Market by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDepth(self, request, context):
        """Get Market Depth
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Markets(self, request, context):
        """Get a list of Markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByMarketAndID(self, request, context):
        """-- Orders --

        Get an Order by Market and Order ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByReference(self, request, context):
        """Get an Order by Pending Order reference (UUID)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrdersByMarket(self, request, context):
        """Get a list of Orders by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrdersByParty(self, request, context):
        """Get a list of Orders by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByID(self, request, context):
        """Get a specific order by order ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderVersionsByID(self, request, context):
        """Get all versions of the order by its orderID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarginLevels(self, request, context):
        """-- Parties --

        Get Margin Levels by Party ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Parties(self, request, context):
        """Get a list of Parties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PartyByID(self, request, context):
        """Get a Party by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PositionsByParty(self, request, context):
        """-- Positions --

        Get a list of Positions by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LastTrade(self, request, context):
        """-- Trades --

        Get latest Trade
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesByMarket(self, request, context):
        """Get a list of Trades by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesByOrder(self, request, context):
        """Get a list of Trades by Order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesByParty(self, request, context):
        """Get a list of Trades by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposals(self, request, context):
        """-- Governance --

        Get governance data (proposals and votes) for all proposals
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposalsByParty(self, request, context):
        """Get governance data (proposals and votes) for proposals by party authoring them
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetVotesByParty(self, request, context):
        """Get votes by party casting them
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNewMarketProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals that aim creating new markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetUpdateMarketProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals that aim updating markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNetworkParametersProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals that aim updating Vega network parameters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNewAssetProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals aiming to create new assets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposalByID(self, request, context):
        """Get governance data (proposals and votes) for a proposal located by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposalByReference(self, request, context):
        """Get governance data (proposals and votes) for a proposal located by reference
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObserveGovernance(self, request, context):
        """Subscribe to a stream of all governance updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObservePartyProposals(self, request, context):
        """Subscribe to a stream of proposal updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObservePartyVotes(self, request, context):
        """Subscribe to a stream of votes cast by a specific party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObserveProposalVotes(self, request, context):
        """Subscribe to a stream of proposal votes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObserveEventBus(self, request_iterator, context):
        """Subscribe to a stream of events from the core
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Statistics(self, request, context):
        """-- Misc --

        Get Statistics on Vega
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetVegaTime(self, request, context):
        """Get Time
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AccountsSubscribe(self, request, context):
        """Subscribe to a stream of Accounts
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CandlesSubscribe(self, request, context):
        """Subscribe to a stream of Candles
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarginLevelsSubscribe(self, request, context):
        """Subscribe to a stream of Margin Levels
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDepthSubscribe(self, request, context):
        """Subscribe to a stream of Market Depth
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDepthUpdatesSubscribe(self, request, context):
        """Subscribe to a stream of Market Depth Price Level Updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketsDataSubscribe(self, request, context):
        """Subscribe to a stream of Markets Data
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrdersSubscribe(self, request, context):
        """Subscribe to a stream of Orders
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PositionsSubscribe(self, request, context):
        """Subscribe to a stream of Positions
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesSubscribe(self, request, context):
        """Subscribe to a stream of Trades
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TransferResponsesSubscribe(self, request, context):
        """Subscribe to a stream of Transfer Responses
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNodeSignaturesAggregate(self, request, context):
        """Get an aggregate of signatures from all the nodes of the network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AssetByID(self, request, context):
        """Get an asset by its identifier
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Assets(self, request, context):
        """Get a list of all assets on Vega
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EstimateFee(self, request, context):
        """Get an estimate for the fee to be paid for a given order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EstimateMargin(self, request, context):
        """Get an estimate for the margin required for a new order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ERC20WithdrawalApproval(self, request, context):
        """Get the bundle approval for an ERC20 withdrawal,
        these data are being used to bundle the call to the smart contract on the ethereum bridge
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Withdrawal(self, request, context):
        """Get a withdrawal by its identifier
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Withdrawals(self, request, context):
        """Get withdrawals for a party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Deposit(self, request, context):
        """Get a deposit by its identifier
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Deposits(self, request, context):
        """Get deposits for a party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NetworkParameters(self, request, context):
        """Get the network parameters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LiquidityProvisions(self, request, context):
        """Get the liquidity provision orders
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OracleSpec(self, request, context):
        """Get an oracle spec by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OracleSpecs(self, request, context):
        """Get the oracle specs
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OracleDataBySpec(self, request, context):
        """Get all oracle data
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TradingDataServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'MarketAccounts': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketAccounts,
                    request_deserializer=api_dot_trading__pb2.MarketAccountsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketAccountsResponse.SerializeToString,
            ),
            'PartyAccounts': grpc.unary_unary_rpc_method_handler(
                    servicer.PartyAccounts,
                    request_deserializer=api_dot_trading__pb2.PartyAccountsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PartyAccountsResponse.SerializeToString,
            ),
            'FeeInfrastructureAccounts': grpc.unary_unary_rpc_method_handler(
                    servicer.FeeInfrastructureAccounts,
                    request_deserializer=api_dot_trading__pb2.FeeInfrastructureAccountsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.FeeInfrastructureAccountsResponse.SerializeToString,
            ),
            'Candles': grpc.unary_unary_rpc_method_handler(
                    servicer.Candles,
                    request_deserializer=api_dot_trading__pb2.CandlesRequest.FromString,
                    response_serializer=api_dot_trading__pb2.CandlesResponse.SerializeToString,
            ),
            'MarketDataByID': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketDataByID,
                    request_deserializer=api_dot_trading__pb2.MarketDataByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketDataByIDResponse.SerializeToString,
            ),
            'MarketsData': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketsData,
                    request_deserializer=api_dot_trading__pb2.MarketsDataRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketsDataResponse.SerializeToString,
            ),
            'MarketByID': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketByID,
                    request_deserializer=api_dot_trading__pb2.MarketByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketByIDResponse.SerializeToString,
            ),
            'MarketDepth': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketDepth,
                    request_deserializer=api_dot_trading__pb2.MarketDepthRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketDepthResponse.SerializeToString,
            ),
            'Markets': grpc.unary_unary_rpc_method_handler(
                    servicer.Markets,
                    request_deserializer=api_dot_trading__pb2.MarketsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketsResponse.SerializeToString,
            ),
            'OrderByMarketAndID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByMarketAndID,
                    request_deserializer=api_dot_trading__pb2.OrderByMarketAndIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrderByMarketAndIDResponse.SerializeToString,
            ),
            'OrderByReference': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByReference,
                    request_deserializer=api_dot_trading__pb2.OrderByReferenceRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrderByReferenceResponse.SerializeToString,
            ),
            'OrdersByMarket': grpc.unary_unary_rpc_method_handler(
                    servicer.OrdersByMarket,
                    request_deserializer=api_dot_trading__pb2.OrdersByMarketRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrdersByMarketResponse.SerializeToString,
            ),
            'OrdersByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.OrdersByParty,
                    request_deserializer=api_dot_trading__pb2.OrdersByPartyRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrdersByPartyResponse.SerializeToString,
            ),
            'OrderByID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByID,
                    request_deserializer=api_dot_trading__pb2.OrderByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrderByIDResponse.SerializeToString,
            ),
            'OrderVersionsByID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderVersionsByID,
                    request_deserializer=api_dot_trading__pb2.OrderVersionsByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrderVersionsByIDResponse.SerializeToString,
            ),
            'MarginLevels': grpc.unary_unary_rpc_method_handler(
                    servicer.MarginLevels,
                    request_deserializer=api_dot_trading__pb2.MarginLevelsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarginLevelsResponse.SerializeToString,
            ),
            'Parties': grpc.unary_unary_rpc_method_handler(
                    servicer.Parties,
                    request_deserializer=api_dot_trading__pb2.PartiesRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PartiesResponse.SerializeToString,
            ),
            'PartyByID': grpc.unary_unary_rpc_method_handler(
                    servicer.PartyByID,
                    request_deserializer=api_dot_trading__pb2.PartyByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PartyByIDResponse.SerializeToString,
            ),
            'PositionsByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.PositionsByParty,
                    request_deserializer=api_dot_trading__pb2.PositionsByPartyRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PositionsByPartyResponse.SerializeToString,
            ),
            'LastTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.LastTrade,
                    request_deserializer=api_dot_trading__pb2.LastTradeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.LastTradeResponse.SerializeToString,
            ),
            'TradesByMarket': grpc.unary_unary_rpc_method_handler(
                    servicer.TradesByMarket,
                    request_deserializer=api_dot_trading__pb2.TradesByMarketRequest.FromString,
                    response_serializer=api_dot_trading__pb2.TradesByMarketResponse.SerializeToString,
            ),
            'TradesByOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.TradesByOrder,
                    request_deserializer=api_dot_trading__pb2.TradesByOrderRequest.FromString,
                    response_serializer=api_dot_trading__pb2.TradesByOrderResponse.SerializeToString,
            ),
            'TradesByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.TradesByParty,
                    request_deserializer=api_dot_trading__pb2.TradesByPartyRequest.FromString,
                    response_serializer=api_dot_trading__pb2.TradesByPartyResponse.SerializeToString,
            ),
            'GetProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposals,
                    request_deserializer=api_dot_trading__pb2.GetProposalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetProposalsResponse.SerializeToString,
            ),
            'GetProposalsByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposalsByParty,
                    request_deserializer=api_dot_trading__pb2.GetProposalsByPartyRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetProposalsByPartyResponse.SerializeToString,
            ),
            'GetVotesByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVotesByParty,
                    request_deserializer=api_dot_trading__pb2.GetVotesByPartyRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetVotesByPartyResponse.SerializeToString,
            ),
            'GetNewMarketProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNewMarketProposals,
                    request_deserializer=api_dot_trading__pb2.GetNewMarketProposalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetNewMarketProposalsResponse.SerializeToString,
            ),
            'GetUpdateMarketProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetUpdateMarketProposals,
                    request_deserializer=api_dot_trading__pb2.GetUpdateMarketProposalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetUpdateMarketProposalsResponse.SerializeToString,
            ),
            'GetNetworkParametersProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNetworkParametersProposals,
                    request_deserializer=api_dot_trading__pb2.GetNetworkParametersProposalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetNetworkParametersProposalsResponse.SerializeToString,
            ),
            'GetNewAssetProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNewAssetProposals,
                    request_deserializer=api_dot_trading__pb2.GetNewAssetProposalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetNewAssetProposalsResponse.SerializeToString,
            ),
            'GetProposalByID': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposalByID,
                    request_deserializer=api_dot_trading__pb2.GetProposalByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetProposalByIDResponse.SerializeToString,
            ),
            'GetProposalByReference': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposalByReference,
                    request_deserializer=api_dot_trading__pb2.GetProposalByReferenceRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetProposalByReferenceResponse.SerializeToString,
            ),
            'ObserveGovernance': grpc.unary_stream_rpc_method_handler(
                    servicer.ObserveGovernance,
                    request_deserializer=api_dot_trading__pb2.ObserveGovernanceRequest.FromString,
                    response_serializer=api_dot_trading__pb2.ObserveGovernanceResponse.SerializeToString,
            ),
            'ObservePartyProposals': grpc.unary_stream_rpc_method_handler(
                    servicer.ObservePartyProposals,
                    request_deserializer=api_dot_trading__pb2.ObservePartyProposalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.ObservePartyProposalsResponse.SerializeToString,
            ),
            'ObservePartyVotes': grpc.unary_stream_rpc_method_handler(
                    servicer.ObservePartyVotes,
                    request_deserializer=api_dot_trading__pb2.ObservePartyVotesRequest.FromString,
                    response_serializer=api_dot_trading__pb2.ObservePartyVotesResponse.SerializeToString,
            ),
            'ObserveProposalVotes': grpc.unary_stream_rpc_method_handler(
                    servicer.ObserveProposalVotes,
                    request_deserializer=api_dot_trading__pb2.ObserveProposalVotesRequest.FromString,
                    response_serializer=api_dot_trading__pb2.ObserveProposalVotesResponse.SerializeToString,
            ),
            'ObserveEventBus': grpc.stream_stream_rpc_method_handler(
                    servicer.ObserveEventBus,
                    request_deserializer=api_dot_trading__pb2.ObserveEventBusRequest.FromString,
                    response_serializer=api_dot_trading__pb2.ObserveEventBusResponse.SerializeToString,
            ),
            'Statistics': grpc.unary_unary_rpc_method_handler(
                    servicer.Statistics,
                    request_deserializer=api_dot_trading__pb2.StatisticsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.StatisticsResponse.SerializeToString,
            ),
            'GetVegaTime': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVegaTime,
                    request_deserializer=api_dot_trading__pb2.GetVegaTimeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetVegaTimeResponse.SerializeToString,
            ),
            'AccountsSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.AccountsSubscribe,
                    request_deserializer=api_dot_trading__pb2.AccountsSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.AccountsSubscribeResponse.SerializeToString,
            ),
            'CandlesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.CandlesSubscribe,
                    request_deserializer=api_dot_trading__pb2.CandlesSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.CandlesSubscribeResponse.SerializeToString,
            ),
            'MarginLevelsSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarginLevelsSubscribe,
                    request_deserializer=api_dot_trading__pb2.MarginLevelsSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarginLevelsSubscribeResponse.SerializeToString,
            ),
            'MarketDepthSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarketDepthSubscribe,
                    request_deserializer=api_dot_trading__pb2.MarketDepthSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketDepthSubscribeResponse.SerializeToString,
            ),
            'MarketDepthUpdatesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarketDepthUpdatesSubscribe,
                    request_deserializer=api_dot_trading__pb2.MarketDepthUpdatesSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketDepthUpdatesSubscribeResponse.SerializeToString,
            ),
            'MarketsDataSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarketsDataSubscribe,
                    request_deserializer=api_dot_trading__pb2.MarketsDataSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.MarketsDataSubscribeResponse.SerializeToString,
            ),
            'OrdersSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.OrdersSubscribe,
                    request_deserializer=api_dot_trading__pb2.OrdersSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OrdersSubscribeResponse.SerializeToString,
            ),
            'PositionsSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.PositionsSubscribe,
                    request_deserializer=api_dot_trading__pb2.PositionsSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.PositionsSubscribeResponse.SerializeToString,
            ),
            'TradesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.TradesSubscribe,
                    request_deserializer=api_dot_trading__pb2.TradesSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.TradesSubscribeResponse.SerializeToString,
            ),
            'TransferResponsesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.TransferResponsesSubscribe,
                    request_deserializer=api_dot_trading__pb2.TransferResponsesSubscribeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.TransferResponsesSubscribeResponse.SerializeToString,
            ),
            'GetNodeSignaturesAggregate': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNodeSignaturesAggregate,
                    request_deserializer=api_dot_trading__pb2.GetNodeSignaturesAggregateRequest.FromString,
                    response_serializer=api_dot_trading__pb2.GetNodeSignaturesAggregateResponse.SerializeToString,
            ),
            'AssetByID': grpc.unary_unary_rpc_method_handler(
                    servicer.AssetByID,
                    request_deserializer=api_dot_trading__pb2.AssetByIDRequest.FromString,
                    response_serializer=api_dot_trading__pb2.AssetByIDResponse.SerializeToString,
            ),
            'Assets': grpc.unary_unary_rpc_method_handler(
                    servicer.Assets,
                    request_deserializer=api_dot_trading__pb2.AssetsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.AssetsResponse.SerializeToString,
            ),
            'EstimateFee': grpc.unary_unary_rpc_method_handler(
                    servicer.EstimateFee,
                    request_deserializer=api_dot_trading__pb2.EstimateFeeRequest.FromString,
                    response_serializer=api_dot_trading__pb2.EstimateFeeResponse.SerializeToString,
            ),
            'EstimateMargin': grpc.unary_unary_rpc_method_handler(
                    servicer.EstimateMargin,
                    request_deserializer=api_dot_trading__pb2.EstimateMarginRequest.FromString,
                    response_serializer=api_dot_trading__pb2.EstimateMarginResponse.SerializeToString,
            ),
            'ERC20WithdrawalApproval': grpc.unary_unary_rpc_method_handler(
                    servicer.ERC20WithdrawalApproval,
                    request_deserializer=api_dot_trading__pb2.ERC20WithdrawalApprovalRequest.FromString,
                    response_serializer=api_dot_trading__pb2.ERC20WithdrawalApprovalResponse.SerializeToString,
            ),
            'Withdrawal': grpc.unary_unary_rpc_method_handler(
                    servicer.Withdrawal,
                    request_deserializer=api_dot_trading__pb2.WithdrawalRequest.FromString,
                    response_serializer=api_dot_trading__pb2.WithdrawalResponse.SerializeToString,
            ),
            'Withdrawals': grpc.unary_unary_rpc_method_handler(
                    servicer.Withdrawals,
                    request_deserializer=api_dot_trading__pb2.WithdrawalsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.WithdrawalsResponse.SerializeToString,
            ),
            'Deposit': grpc.unary_unary_rpc_method_handler(
                    servicer.Deposit,
                    request_deserializer=api_dot_trading__pb2.DepositRequest.FromString,
                    response_serializer=api_dot_trading__pb2.DepositResponse.SerializeToString,
            ),
            'Deposits': grpc.unary_unary_rpc_method_handler(
                    servicer.Deposits,
                    request_deserializer=api_dot_trading__pb2.DepositsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.DepositsResponse.SerializeToString,
            ),
            'NetworkParameters': grpc.unary_unary_rpc_method_handler(
                    servicer.NetworkParameters,
                    request_deserializer=api_dot_trading__pb2.NetworkParametersRequest.FromString,
                    response_serializer=api_dot_trading__pb2.NetworkParametersResponse.SerializeToString,
            ),
            'LiquidityProvisions': grpc.unary_unary_rpc_method_handler(
                    servicer.LiquidityProvisions,
                    request_deserializer=api_dot_trading__pb2.LiquidityProvisionsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.LiquidityProvisionsResponse.SerializeToString,
            ),
            'OracleSpec': grpc.unary_unary_rpc_method_handler(
                    servicer.OracleSpec,
                    request_deserializer=api_dot_trading__pb2.OracleSpecRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OracleSpecResponse.SerializeToString,
            ),
            'OracleSpecs': grpc.unary_unary_rpc_method_handler(
                    servicer.OracleSpecs,
                    request_deserializer=api_dot_trading__pb2.OracleSpecsRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OracleSpecsResponse.SerializeToString,
            ),
            'OracleDataBySpec': grpc.unary_unary_rpc_method_handler(
                    servicer.OracleDataBySpec,
                    request_deserializer=api_dot_trading__pb2.OracleDataBySpecRequest.FromString,
                    response_serializer=api_dot_trading__pb2.OracleDataBySpecResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'api.v1.TradingDataService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class TradingDataService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def MarketAccounts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/MarketAccounts',
            api_dot_trading__pb2.MarketAccountsRequest.SerializeToString,
            api_dot_trading__pb2.MarketAccountsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PartyAccounts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/PartyAccounts',
            api_dot_trading__pb2.PartyAccountsRequest.SerializeToString,
            api_dot_trading__pb2.PartyAccountsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FeeInfrastructureAccounts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/FeeInfrastructureAccounts',
            api_dot_trading__pb2.FeeInfrastructureAccountsRequest.SerializeToString,
            api_dot_trading__pb2.FeeInfrastructureAccountsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Candles(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Candles',
            api_dot_trading__pb2.CandlesRequest.SerializeToString,
            api_dot_trading__pb2.CandlesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDataByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/MarketDataByID',
            api_dot_trading__pb2.MarketDataByIDRequest.SerializeToString,
            api_dot_trading__pb2.MarketDataByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketsData(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/MarketsData',
            api_dot_trading__pb2.MarketsDataRequest.SerializeToString,
            api_dot_trading__pb2.MarketsDataResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/MarketByID',
            api_dot_trading__pb2.MarketByIDRequest.SerializeToString,
            api_dot_trading__pb2.MarketByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDepth(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/MarketDepth',
            api_dot_trading__pb2.MarketDepthRequest.SerializeToString,
            api_dot_trading__pb2.MarketDepthResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Markets(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Markets',
            api_dot_trading__pb2.MarketsRequest.SerializeToString,
            api_dot_trading__pb2.MarketsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByMarketAndID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OrderByMarketAndID',
            api_dot_trading__pb2.OrderByMarketAndIDRequest.SerializeToString,
            api_dot_trading__pb2.OrderByMarketAndIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByReference(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OrderByReference',
            api_dot_trading__pb2.OrderByReferenceRequest.SerializeToString,
            api_dot_trading__pb2.OrderByReferenceResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrdersByMarket(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OrdersByMarket',
            api_dot_trading__pb2.OrdersByMarketRequest.SerializeToString,
            api_dot_trading__pb2.OrdersByMarketResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrdersByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OrdersByParty',
            api_dot_trading__pb2.OrdersByPartyRequest.SerializeToString,
            api_dot_trading__pb2.OrdersByPartyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OrderByID',
            api_dot_trading__pb2.OrderByIDRequest.SerializeToString,
            api_dot_trading__pb2.OrderByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderVersionsByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OrderVersionsByID',
            api_dot_trading__pb2.OrderVersionsByIDRequest.SerializeToString,
            api_dot_trading__pb2.OrderVersionsByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarginLevels(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/MarginLevels',
            api_dot_trading__pb2.MarginLevelsRequest.SerializeToString,
            api_dot_trading__pb2.MarginLevelsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Parties(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Parties',
            api_dot_trading__pb2.PartiesRequest.SerializeToString,
            api_dot_trading__pb2.PartiesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PartyByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/PartyByID',
            api_dot_trading__pb2.PartyByIDRequest.SerializeToString,
            api_dot_trading__pb2.PartyByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PositionsByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/PositionsByParty',
            api_dot_trading__pb2.PositionsByPartyRequest.SerializeToString,
            api_dot_trading__pb2.PositionsByPartyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LastTrade(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/LastTrade',
            api_dot_trading__pb2.LastTradeRequest.SerializeToString,
            api_dot_trading__pb2.LastTradeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesByMarket(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/TradesByMarket',
            api_dot_trading__pb2.TradesByMarketRequest.SerializeToString,
            api_dot_trading__pb2.TradesByMarketResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesByOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/TradesByOrder',
            api_dot_trading__pb2.TradesByOrderRequest.SerializeToString,
            api_dot_trading__pb2.TradesByOrderResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/TradesByParty',
            api_dot_trading__pb2.TradesByPartyRequest.SerializeToString,
            api_dot_trading__pb2.TradesByPartyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetProposals',
            api_dot_trading__pb2.GetProposalsRequest.SerializeToString,
            api_dot_trading__pb2.GetProposalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposalsByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetProposalsByParty',
            api_dot_trading__pb2.GetProposalsByPartyRequest.SerializeToString,
            api_dot_trading__pb2.GetProposalsByPartyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetVotesByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetVotesByParty',
            api_dot_trading__pb2.GetVotesByPartyRequest.SerializeToString,
            api_dot_trading__pb2.GetVotesByPartyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNewMarketProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetNewMarketProposals',
            api_dot_trading__pb2.GetNewMarketProposalsRequest.SerializeToString,
            api_dot_trading__pb2.GetNewMarketProposalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetUpdateMarketProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetUpdateMarketProposals',
            api_dot_trading__pb2.GetUpdateMarketProposalsRequest.SerializeToString,
            api_dot_trading__pb2.GetUpdateMarketProposalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNetworkParametersProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetNetworkParametersProposals',
            api_dot_trading__pb2.GetNetworkParametersProposalsRequest.SerializeToString,
            api_dot_trading__pb2.GetNetworkParametersProposalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNewAssetProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetNewAssetProposals',
            api_dot_trading__pb2.GetNewAssetProposalsRequest.SerializeToString,
            api_dot_trading__pb2.GetNewAssetProposalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposalByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetProposalByID',
            api_dot_trading__pb2.GetProposalByIDRequest.SerializeToString,
            api_dot_trading__pb2.GetProposalByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposalByReference(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetProposalByReference',
            api_dot_trading__pb2.GetProposalByReferenceRequest.SerializeToString,
            api_dot_trading__pb2.GetProposalByReferenceResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObserveGovernance(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/ObserveGovernance',
            api_dot_trading__pb2.ObserveGovernanceRequest.SerializeToString,
            api_dot_trading__pb2.ObserveGovernanceResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObservePartyProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/ObservePartyProposals',
            api_dot_trading__pb2.ObservePartyProposalsRequest.SerializeToString,
            api_dot_trading__pb2.ObservePartyProposalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObservePartyVotes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/ObservePartyVotes',
            api_dot_trading__pb2.ObservePartyVotesRequest.SerializeToString,
            api_dot_trading__pb2.ObservePartyVotesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObserveProposalVotes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/ObserveProposalVotes',
            api_dot_trading__pb2.ObserveProposalVotesRequest.SerializeToString,
            api_dot_trading__pb2.ObserveProposalVotesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObserveEventBus(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(request_iterator, target, '/api.v1.TradingDataService/ObserveEventBus',
            api_dot_trading__pb2.ObserveEventBusRequest.SerializeToString,
            api_dot_trading__pb2.ObserveEventBusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Statistics(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Statistics',
            api_dot_trading__pb2.StatisticsRequest.SerializeToString,
            api_dot_trading__pb2.StatisticsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetVegaTime(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetVegaTime',
            api_dot_trading__pb2.GetVegaTimeRequest.SerializeToString,
            api_dot_trading__pb2.GetVegaTimeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AccountsSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/AccountsSubscribe',
            api_dot_trading__pb2.AccountsSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.AccountsSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CandlesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/CandlesSubscribe',
            api_dot_trading__pb2.CandlesSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.CandlesSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarginLevelsSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/MarginLevelsSubscribe',
            api_dot_trading__pb2.MarginLevelsSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.MarginLevelsSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDepthSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/MarketDepthSubscribe',
            api_dot_trading__pb2.MarketDepthSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.MarketDepthSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDepthUpdatesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/MarketDepthUpdatesSubscribe',
            api_dot_trading__pb2.MarketDepthUpdatesSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.MarketDepthUpdatesSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketsDataSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/MarketsDataSubscribe',
            api_dot_trading__pb2.MarketsDataSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.MarketsDataSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrdersSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/OrdersSubscribe',
            api_dot_trading__pb2.OrdersSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.OrdersSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PositionsSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/PositionsSubscribe',
            api_dot_trading__pb2.PositionsSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.PositionsSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/TradesSubscribe',
            api_dot_trading__pb2.TradesSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.TradesSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TransferResponsesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.v1.TradingDataService/TransferResponsesSubscribe',
            api_dot_trading__pb2.TransferResponsesSubscribeRequest.SerializeToString,
            api_dot_trading__pb2.TransferResponsesSubscribeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNodeSignaturesAggregate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/GetNodeSignaturesAggregate',
            api_dot_trading__pb2.GetNodeSignaturesAggregateRequest.SerializeToString,
            api_dot_trading__pb2.GetNodeSignaturesAggregateResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AssetByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/AssetByID',
            api_dot_trading__pb2.AssetByIDRequest.SerializeToString,
            api_dot_trading__pb2.AssetByIDResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Assets(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Assets',
            api_dot_trading__pb2.AssetsRequest.SerializeToString,
            api_dot_trading__pb2.AssetsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def EstimateFee(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/EstimateFee',
            api_dot_trading__pb2.EstimateFeeRequest.SerializeToString,
            api_dot_trading__pb2.EstimateFeeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def EstimateMargin(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/EstimateMargin',
            api_dot_trading__pb2.EstimateMarginRequest.SerializeToString,
            api_dot_trading__pb2.EstimateMarginResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ERC20WithdrawalApproval(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/ERC20WithdrawalApproval',
            api_dot_trading__pb2.ERC20WithdrawalApprovalRequest.SerializeToString,
            api_dot_trading__pb2.ERC20WithdrawalApprovalResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Withdrawal(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Withdrawal',
            api_dot_trading__pb2.WithdrawalRequest.SerializeToString,
            api_dot_trading__pb2.WithdrawalResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Withdrawals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Withdrawals',
            api_dot_trading__pb2.WithdrawalsRequest.SerializeToString,
            api_dot_trading__pb2.WithdrawalsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Deposit(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Deposit',
            api_dot_trading__pb2.DepositRequest.SerializeToString,
            api_dot_trading__pb2.DepositResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Deposits(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/Deposits',
            api_dot_trading__pb2.DepositsRequest.SerializeToString,
            api_dot_trading__pb2.DepositsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NetworkParameters(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/NetworkParameters',
            api_dot_trading__pb2.NetworkParametersRequest.SerializeToString,
            api_dot_trading__pb2.NetworkParametersResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LiquidityProvisions(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/LiquidityProvisions',
            api_dot_trading__pb2.LiquidityProvisionsRequest.SerializeToString,
            api_dot_trading__pb2.LiquidityProvisionsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OracleSpec(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OracleSpec',
            api_dot_trading__pb2.OracleSpecRequest.SerializeToString,
            api_dot_trading__pb2.OracleSpecResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OracleSpecs(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OracleSpecs',
            api_dot_trading__pb2.OracleSpecsRequest.SerializeToString,
            api_dot_trading__pb2.OracleSpecsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OracleDataBySpec(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.v1.TradingDataService/OracleDataBySpec',
            api_dot_trading__pb2.OracleDataBySpecRequest.SerializeToString,
            api_dot_trading__pb2.OracleDataBySpecResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
