grpcoin_pb2_grpc.py

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

import grpcoin_pb2 as grpcoin__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Watch = channel.unary_stream(
                '/grpcoin.TickerInfo/Watch',
                request_serializer=grpcoin__pb2.TickerWatchRequest.SerializeToString,
                response_deserializer=grpcoin__pb2.Quote.FromString,
                )


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

    def Watch(self, request, context):
        """Watch returns real-time quotes of the ticker.
        The only supported tickers are "BTC", "ETH", "DOGE", "DOT".

        This stream terminates after 15 minutes, so expect being
        abruptly disconnected and need to reconnect.

        No authentication required.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TickerInfoServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Watch': grpc.unary_stream_rpc_method_handler(
                    servicer.Watch,
                    request_deserializer=grpcoin__pb2.TickerWatchRequest.FromString,
                    response_serializer=grpcoin__pb2.Quote.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'grpcoin.TickerInfo', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def Watch(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, '/grpcoin.TickerInfo/Watch',
            grpcoin__pb2.TickerWatchRequest.SerializeToString,
            grpcoin__pb2.Quote.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Portfolio = channel.unary_unary(
                '/grpcoin.PaperTrade/Portfolio',
                request_serializer=grpcoin__pb2.PortfolioRequest.SerializeToString,
                response_deserializer=grpcoin__pb2.PortfolioResponse.FromString,
                )
        self.Trade = channel.unary_unary(
                '/grpcoin.PaperTrade/Trade',
                request_serializer=grpcoin__pb2.TradeRequest.SerializeToString,
                response_deserializer=grpcoin__pb2.TradeResponse.FromString,
                )
        self.ListSupportedCurrencies = channel.unary_unary(
                '/grpcoin.PaperTrade/ListSupportedCurrencies',
                request_serializer=grpcoin__pb2.ListSupportedCurrenciesRequest.SerializeToString,
                response_deserializer=grpcoin__pb2.ListSupportedCurrenciesResponse.FromString,
                )


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

    def Portfolio(self, request, context):
        """Returns authenticated user's portfolio.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Trade(self, request, context):
        """Executes a trade in authenticated user's portfolio.
        All trades are executed immediately with the real-time market
        price provided on TickerInfo.Watch endpoint.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListSupportedCurrencies(self, request, context):
        """Returns symbols supported by Trade or Watch methods.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_PaperTradeServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Portfolio': grpc.unary_unary_rpc_method_handler(
                    servicer.Portfolio,
                    request_deserializer=grpcoin__pb2.PortfolioRequest.FromString,
                    response_serializer=grpcoin__pb2.PortfolioResponse.SerializeToString,
            ),
            'Trade': grpc.unary_unary_rpc_method_handler(
                    servicer.Trade,
                    request_deserializer=grpcoin__pb2.TradeRequest.FromString,
                    response_serializer=grpcoin__pb2.TradeResponse.SerializeToString,
            ),
            'ListSupportedCurrencies': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSupportedCurrencies,
                    request_deserializer=grpcoin__pb2.ListSupportedCurrenciesRequest.FromString,
                    response_serializer=grpcoin__pb2.ListSupportedCurrenciesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'grpcoin.PaperTrade', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def Portfolio(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, '/grpcoin.PaperTrade/Portfolio',
            grpcoin__pb2.PortfolioRequest.SerializeToString,
            grpcoin__pb2.PortfolioResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Trade(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, '/grpcoin.PaperTrade/Trade',
            grpcoin__pb2.TradeRequest.SerializeToString,
            grpcoin__pb2.TradeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListSupportedCurrencies(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, '/grpcoin.PaperTrade/ListSupportedCurrencies',
            grpcoin__pb2.ListSupportedCurrenciesRequest.SerializeToString,
            grpcoin__pb2.ListSupportedCurrenciesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.TestAuth = channel.unary_unary(
                '/grpcoin.Account/TestAuth',
                request_serializer=grpcoin__pb2.TestAuthRequest.SerializeToString,
                response_deserializer=grpcoin__pb2.TestAuthResponse.FromString,
                )


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

    def TestAuth(self, request, context):
        """Tests if your token works.

        Send a header (gRPC metadata) named "Authorization"
        with value "Bearer XXX" where XXX is a GitHub Personal Access token
        from https://github.com/settings/tokens (no permissions needed).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_AccountServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'TestAuth': grpc.unary_unary_rpc_method_handler(
                    servicer.TestAuth,
                    request_deserializer=grpcoin__pb2.TestAuthRequest.FromString,
                    response_serializer=grpcoin__pb2.TestAuthResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'grpcoin.Account', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def TestAuth(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, '/grpcoin.Account/TestAuth',
            grpcoin__pb2.TestAuthRequest.SerializeToString,
            grpcoin__pb2.TestAuthResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)