<reponame>dappley/dappley-sdk-python
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc

import rpc_pb2 as rpc__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.RpcGetVersion = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetVersion',
                request_serializer=rpc__pb2.GetVersionRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetVersionResponse.FromString,
                )
        self.RpcGetBalance = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetBalance',
                request_serializer=rpc__pb2.GetBalanceRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetBalanceResponse.FromString,
                )
        self.RpcGetBlockchainInfo = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetBlockchainInfo',
                request_serializer=rpc__pb2.GetBlockchainInfoRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetBlockchainInfoResponse.FromString,
                )
        self.RpcGetUTXO = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetUTXO',
                request_serializer=rpc__pb2.GetUTXORequest.SerializeToString,
                response_deserializer=rpc__pb2.GetUTXOResponse.FromString,
                )
        self.RpcGetBlocks = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetBlocks',
                request_serializer=rpc__pb2.GetBlocksRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetBlocksResponse.FromString,
                )
        self.RpcGetBlockByHash = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetBlockByHash',
                request_serializer=rpc__pb2.GetBlockByHashRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetBlockByHashResponse.FromString,
                )
        self.RpcGetBlockByHeight = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetBlockByHeight',
                request_serializer=rpc__pb2.GetBlockByHeightRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetBlockByHeightResponse.FromString,
                )
        self.RpcSendTransaction = channel.unary_unary(
                '/rpcpb.RpcService/RpcSendTransaction',
                request_serializer=rpc__pb2.SendTransactionRequest.SerializeToString,
                response_deserializer=rpc__pb2.SendTransactionResponse.FromString,
                )
        self.RpcSendBatchTransaction = channel.unary_unary(
                '/rpcpb.RpcService/RpcSendBatchTransaction',
                request_serializer=rpc__pb2.SendBatchTransactionRequest.SerializeToString,
                response_deserializer=rpc__pb2.SendBatchTransactionResponse.FromString,
                )
        self.RpcGetNewTransaction = channel.unary_stream(
                '/rpcpb.RpcService/RpcGetNewTransaction',
                request_serializer=rpc__pb2.GetNewTransactionRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetNewTransactionResponse.FromString,
                )
        self.RpcSubscribe = channel.unary_stream(
                '/rpcpb.RpcService/RpcSubscribe',
                request_serializer=rpc__pb2.SubscribeRequest.SerializeToString,
                response_deserializer=rpc__pb2.SubscribeResponse.FromString,
                )
        self.RpcGetAllTransactionsFromTxPool = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetAllTransactionsFromTxPool',
                request_serializer=rpc__pb2.GetAllTransactionsRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetAllTransactionsResponse.FromString,
                )
        self.RpcGetLastIrreversibleBlock = channel.unary_unary(
                '/rpcpb.RpcService/RpcGetLastIrreversibleBlock',
                request_serializer=rpc__pb2.GetLastIrreversibleBlockRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetLastIrreversibleBlockResponse.FromString,
                )
        self.RpcEstimateGas = channel.unary_unary(
                '/rpcpb.RpcService/RpcEstimateGas',
                request_serializer=rpc__pb2.EstimateGasRequest.SerializeToString,
                response_deserializer=rpc__pb2.EstimateGasResponse.FromString,
                )
        self.RpcGasPrice = channel.unary_unary(
                '/rpcpb.RpcService/RpcGasPrice',
                request_serializer=rpc__pb2.GasPriceRequest.SerializeToString,
                response_deserializer=rpc__pb2.GasPriceResponse.FromString,
                )
        self.RpcContractQuery = channel.unary_unary(
                '/rpcpb.RpcService/RpcContractQuery',
                request_serializer=rpc__pb2.ContractQueryRequest.SerializeToString,
                response_deserializer=rpc__pb2.ContractQueryResponse.FromString,
                )


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

    def RpcGetVersion(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetBalance(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetBlockchainInfo(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetUTXO(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetBlocks(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetBlockByHash(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetBlockByHeight(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcSendTransaction(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcSendBatchTransaction(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetNewTransaction(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcSubscribe(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetAllTransactionsFromTxPool(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetLastIrreversibleBlock(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcEstimateGas(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGasPrice(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcContractQuery(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_RpcServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RpcGetVersion': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetVersion,
                    request_deserializer=rpc__pb2.GetVersionRequest.FromString,
                    response_serializer=rpc__pb2.GetVersionResponse.SerializeToString,
            ),
            'RpcGetBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetBalance,
                    request_deserializer=rpc__pb2.GetBalanceRequest.FromString,
                    response_serializer=rpc__pb2.GetBalanceResponse.SerializeToString,
            ),
            'RpcGetBlockchainInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetBlockchainInfo,
                    request_deserializer=rpc__pb2.GetBlockchainInfoRequest.FromString,
                    response_serializer=rpc__pb2.GetBlockchainInfoResponse.SerializeToString,
            ),
            'RpcGetUTXO': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetUTXO,
                    request_deserializer=rpc__pb2.GetUTXORequest.FromString,
                    response_serializer=rpc__pb2.GetUTXOResponse.SerializeToString,
            ),
            'RpcGetBlocks': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetBlocks,
                    request_deserializer=rpc__pb2.GetBlocksRequest.FromString,
                    response_serializer=rpc__pb2.GetBlocksResponse.SerializeToString,
            ),
            'RpcGetBlockByHash': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetBlockByHash,
                    request_deserializer=rpc__pb2.GetBlockByHashRequest.FromString,
                    response_serializer=rpc__pb2.GetBlockByHashResponse.SerializeToString,
            ),
            'RpcGetBlockByHeight': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetBlockByHeight,
                    request_deserializer=rpc__pb2.GetBlockByHeightRequest.FromString,
                    response_serializer=rpc__pb2.GetBlockByHeightResponse.SerializeToString,
            ),
            'RpcSendTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcSendTransaction,
                    request_deserializer=rpc__pb2.SendTransactionRequest.FromString,
                    response_serializer=rpc__pb2.SendTransactionResponse.SerializeToString,
            ),
            'RpcSendBatchTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcSendBatchTransaction,
                    request_deserializer=rpc__pb2.SendBatchTransactionRequest.FromString,
                    response_serializer=rpc__pb2.SendBatchTransactionResponse.SerializeToString,
            ),
            'RpcGetNewTransaction': grpc.unary_stream_rpc_method_handler(
                    servicer.RpcGetNewTransaction,
                    request_deserializer=rpc__pb2.GetNewTransactionRequest.FromString,
                    response_serializer=rpc__pb2.GetNewTransactionResponse.SerializeToString,
            ),
            'RpcSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.RpcSubscribe,
                    request_deserializer=rpc__pb2.SubscribeRequest.FromString,
                    response_serializer=rpc__pb2.SubscribeResponse.SerializeToString,
            ),
            'RpcGetAllTransactionsFromTxPool': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetAllTransactionsFromTxPool,
                    request_deserializer=rpc__pb2.GetAllTransactionsRequest.FromString,
                    response_serializer=rpc__pb2.GetAllTransactionsResponse.SerializeToString,
            ),
            'RpcGetLastIrreversibleBlock': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetLastIrreversibleBlock,
                    request_deserializer=rpc__pb2.GetLastIrreversibleBlockRequest.FromString,
                    response_serializer=rpc__pb2.GetLastIrreversibleBlockResponse.SerializeToString,
            ),
            'RpcEstimateGas': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcEstimateGas,
                    request_deserializer=rpc__pb2.EstimateGasRequest.FromString,
                    response_serializer=rpc__pb2.EstimateGasResponse.SerializeToString,
            ),
            'RpcGasPrice': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGasPrice,
                    request_deserializer=rpc__pb2.GasPriceRequest.FromString,
                    response_serializer=rpc__pb2.GasPriceResponse.SerializeToString,
            ),
            'RpcContractQuery': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcContractQuery,
                    request_deserializer=rpc__pb2.ContractQueryRequest.FromString,
                    response_serializer=rpc__pb2.ContractQueryResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'rpcpb.RpcService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def RpcGetVersion(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetVersion',
            rpc__pb2.GetVersionRequest.SerializeToString,
            rpc__pb2.GetVersionResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetBalance(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetBalance',
            rpc__pb2.GetBalanceRequest.SerializeToString,
            rpc__pb2.GetBalanceResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetBlockchainInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetBlockchainInfo',
            rpc__pb2.GetBlockchainInfoRequest.SerializeToString,
            rpc__pb2.GetBlockchainInfoResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetUTXO(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetUTXO',
            rpc__pb2.GetUTXORequest.SerializeToString,
            rpc__pb2.GetUTXOResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetBlocks(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetBlocks',
            rpc__pb2.GetBlocksRequest.SerializeToString,
            rpc__pb2.GetBlocksResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetBlockByHash(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetBlockByHash',
            rpc__pb2.GetBlockByHashRequest.SerializeToString,
            rpc__pb2.GetBlockByHashResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetBlockByHeight(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetBlockByHeight',
            rpc__pb2.GetBlockByHeightRequest.SerializeToString,
            rpc__pb2.GetBlockByHeightResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcSendTransaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcSendTransaction',
            rpc__pb2.SendTransactionRequest.SerializeToString,
            rpc__pb2.SendTransactionResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcSendBatchTransaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcSendBatchTransaction',
            rpc__pb2.SendBatchTransactionRequest.SerializeToString,
            rpc__pb2.SendBatchTransactionResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetNewTransaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/rpcpb.RpcService/RpcGetNewTransaction',
            rpc__pb2.GetNewTransactionRequest.SerializeToString,
            rpc__pb2.GetNewTransactionResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/rpcpb.RpcService/RpcSubscribe',
            rpc__pb2.SubscribeRequest.SerializeToString,
            rpc__pb2.SubscribeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetAllTransactionsFromTxPool(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetAllTransactionsFromTxPool',
            rpc__pb2.GetAllTransactionsRequest.SerializeToString,
            rpc__pb2.GetAllTransactionsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetLastIrreversibleBlock(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGetLastIrreversibleBlock',
            rpc__pb2.GetLastIrreversibleBlockRequest.SerializeToString,
            rpc__pb2.GetLastIrreversibleBlockResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcEstimateGas(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcEstimateGas',
            rpc__pb2.EstimateGasRequest.SerializeToString,
            rpc__pb2.EstimateGasResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGasPrice(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcGasPrice',
            rpc__pb2.GasPriceRequest.SerializeToString,
            rpc__pb2.GasPriceResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcContractQuery(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.RpcService/RpcContractQuery',
            rpc__pb2.ContractQueryRequest.SerializeToString,
            rpc__pb2.ContractQueryResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.RpcAddPeer = channel.unary_unary(
                '/rpcpb.AdminService/RpcAddPeer',
                request_serializer=rpc__pb2.AddPeerRequest.SerializeToString,
                response_deserializer=rpc__pb2.AddPeerResponse.FromString,
                )
        self.RpcSend = channel.unary_unary(
                '/rpcpb.AdminService/RpcSend',
                request_serializer=rpc__pb2.SendRequest.SerializeToString,
                response_deserializer=rpc__pb2.SendResponse.FromString,
                )
        self.RpcGetPeerInfo = channel.unary_unary(
                '/rpcpb.AdminService/RpcGetPeerInfo',
                request_serializer=rpc__pb2.GetPeerInfoRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetPeerInfoResponse.FromString,
                )
        self.RpcSendFromMiner = channel.unary_unary(
                '/rpcpb.AdminService/RpcSendFromMiner',
                request_serializer=rpc__pb2.SendFromMinerRequest.SerializeToString,
                response_deserializer=rpc__pb2.SendFromMinerResponse.FromString,
                )
        self.RpcAddProducer = channel.unary_unary(
                '/rpcpb.AdminService/RpcAddProducer',
                request_serializer=rpc__pb2.AddProducerRequest.SerializeToString,
                response_deserializer=rpc__pb2.AddProducerResponse.FromString,
                )
        self.RpcUnlockAccount = channel.unary_unary(
                '/rpcpb.AdminService/RpcUnlockAccount',
                request_serializer=rpc__pb2.UnlockAccountRequest.SerializeToString,
                response_deserializer=rpc__pb2.UnlockAccountResponse.FromString,
                )


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

    def RpcAddPeer(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcSend(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetPeerInfo(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcSendFromMiner(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcAddProducer(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcUnlockAccount(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_AdminServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RpcAddPeer': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcAddPeer,
                    request_deserializer=rpc__pb2.AddPeerRequest.FromString,
                    response_serializer=rpc__pb2.AddPeerResponse.SerializeToString,
            ),
            'RpcSend': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcSend,
                    request_deserializer=rpc__pb2.SendRequest.FromString,
                    response_serializer=rpc__pb2.SendResponse.SerializeToString,
            ),
            'RpcGetPeerInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetPeerInfo,
                    request_deserializer=rpc__pb2.GetPeerInfoRequest.FromString,
                    response_serializer=rpc__pb2.GetPeerInfoResponse.SerializeToString,
            ),
            'RpcSendFromMiner': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcSendFromMiner,
                    request_deserializer=rpc__pb2.SendFromMinerRequest.FromString,
                    response_serializer=rpc__pb2.SendFromMinerResponse.SerializeToString,
            ),
            'RpcAddProducer': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcAddProducer,
                    request_deserializer=rpc__pb2.AddProducerRequest.FromString,
                    response_serializer=rpc__pb2.AddProducerResponse.SerializeToString,
            ),
            'RpcUnlockAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcUnlockAccount,
                    request_deserializer=rpc__pb2.UnlockAccountRequest.FromString,
                    response_serializer=rpc__pb2.UnlockAccountResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'rpcpb.AdminService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def RpcAddPeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.AdminService/RpcAddPeer',
            rpc__pb2.AddPeerRequest.SerializeToString,
            rpc__pb2.AddPeerResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcSend(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.AdminService/RpcSend',
            rpc__pb2.SendRequest.SerializeToString,
            rpc__pb2.SendResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetPeerInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.AdminService/RpcGetPeerInfo',
            rpc__pb2.GetPeerInfoRequest.SerializeToString,
            rpc__pb2.GetPeerInfoResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcSendFromMiner(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.AdminService/RpcSendFromMiner',
            rpc__pb2.SendFromMinerRequest.SerializeToString,
            rpc__pb2.SendFromMinerResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcAddProducer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.AdminService/RpcAddProducer',
            rpc__pb2.AddProducerRequest.SerializeToString,
            rpc__pb2.AddProducerResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcUnlockAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.AdminService/RpcUnlockAccount',
            rpc__pb2.UnlockAccountRequest.SerializeToString,
            rpc__pb2.UnlockAccountResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.RpcGetStats = channel.unary_unary(
                '/rpcpb.MetricService/RpcGetStats',
                request_serializer=rpc__pb2.MetricsServiceRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetStatsResponse.FromString,
                )
        self.RpcGetNodeConfig = channel.unary_unary(
                '/rpcpb.MetricService/RpcGetNodeConfig',
                request_serializer=rpc__pb2.MetricsServiceRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetNodeConfigResponse.FromString,
                )
        self.RpcSetNodeConfig = channel.unary_unary(
                '/rpcpb.MetricService/RpcSetNodeConfig',
                request_serializer=rpc__pb2.SetNodeConfigRequest.SerializeToString,
                response_deserializer=rpc__pb2.GetNodeConfigResponse.FromString,
                )


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

    def RpcGetStats(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcGetNodeConfig(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RpcSetNodeConfig(self, request, context):
        """Missing associated documentation comment in .proto file"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_MetricServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RpcGetStats': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetStats,
                    request_deserializer=rpc__pb2.MetricsServiceRequest.FromString,
                    response_serializer=rpc__pb2.GetStatsResponse.SerializeToString,
            ),
            'RpcGetNodeConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcGetNodeConfig,
                    request_deserializer=rpc__pb2.MetricsServiceRequest.FromString,
                    response_serializer=rpc__pb2.GetNodeConfigResponse.SerializeToString,
            ),
            'RpcSetNodeConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.RpcSetNodeConfig,
                    request_deserializer=rpc__pb2.SetNodeConfigRequest.FromString,
                    response_serializer=rpc__pb2.GetNodeConfigResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'rpcpb.MetricService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def RpcGetStats(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.MetricService/RpcGetStats',
            rpc__pb2.MetricsServiceRequest.SerializeToString,
            rpc__pb2.GetStatsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcGetNodeConfig(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.MetricService/RpcGetNodeConfig',
            rpc__pb2.MetricsServiceRequest.SerializeToString,
            rpc__pb2.GetNodeConfigResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RpcSetNodeConfig(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.MetricService/RpcSetNodeConfig',
            rpc__pb2.SetNodeConfigRequest.SerializeToString,
            rpc__pb2.GetNodeConfigResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)
