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

from blitskrieg import blitskrieg_pb2 as blitskrieg_dot_blitskrieg__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateStack = channel.unary_unary(
                '/blits.Blitskrieg/CreateStack',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.CreateStackRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.CreateStackResponse.FromString,
                )
        self.GetInfo = channel.unary_unary(
                '/blits.Blitskrieg/GetInfo',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.GetInfoRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.GetInfoResponse.FromString,
                )
        self.RemoveStack = channel.unary_unary(
                '/blits.Blitskrieg/RemoveStack',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.RemoveStackRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.RemoveStackResponse.FromString,
                )


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

    def CreateStack(self, request, context):
        """*
        Create a docker stack with the requested LN nodes.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetInfo(self, request, context):
        """*
        Get BLITSkrieg info.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveStack(self, request, context):
        """*
        Remove any existing docker stack.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_BlitskriegServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateStack': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateStack,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.CreateStackRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.CreateStackResponse.SerializeToString,
            ),
            'GetInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInfo,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.GetInfoRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.GetInfoResponse.SerializeToString,
            ),
            'RemoveStack': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveStack,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.RemoveStackRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.RemoveStackResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'blits.Blitskrieg', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def CreateStack(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, '/blits.Blitskrieg/CreateStack',
            blitskrieg_dot_blitskrieg__pb2.CreateStackRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.CreateStackResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetInfo(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, '/blits.Blitskrieg/GetInfo',
            blitskrieg_dot_blitskrieg__pb2.GetInfoRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.GetInfoResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RemoveStack(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, '/blits.Blitskrieg/RemoveStack',
            blitskrieg_dot_blitskrieg__pb2.RemoveStackRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.RemoveStackResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetAddress = channel.unary_unary(
                '/blits.Bitcoin/GetAddress',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.GetAddressRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.GetAddressResponse.FromString,
                )
        self.GenTransactions = channel.unary_unary(
                '/blits.Bitcoin/GenTransactions',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.GenTransactionsRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.GenTransactionsResponse.FromString,
                )
        self.MineBlock = channel.unary_unary(
                '/blits.Bitcoin/MineBlock',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.MineBlockRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.MineBlockResponse.FromString,
                )
        self.Send = channel.unary_unary(
                '/blits.Bitcoin/Send',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.SendRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.SendResponse.FromString,
                )


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

    def GetAddress(self, request, context):
        """*
        Get a bitcoin address.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GenTransactions(self, request, context):
        """*
        Generate the requested number of blocks, each containing the requested
        number of transactions with the specified number of inputs and outputs.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MineBlock(self, request, context):
        """*
        Mine the requested number of blocks, optionally sending the mining reward
        to a specific address.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Send(self, request, context):
        """*
        Send the requested amount of BTC to the requested address.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_BitcoinServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAddress,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.GetAddressRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.GetAddressResponse.SerializeToString,
            ),
            'GenTransactions': grpc.unary_unary_rpc_method_handler(
                    servicer.GenTransactions,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.GenTransactionsRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.GenTransactionsResponse.SerializeToString,
            ),
            'MineBlock': grpc.unary_unary_rpc_method_handler(
                    servicer.MineBlock,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.MineBlockRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.MineBlockResponse.SerializeToString,
            ),
            'Send': grpc.unary_unary_rpc_method_handler(
                    servicer.Send,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.SendRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.SendResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'blits.Bitcoin', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def GetAddress(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, '/blits.Bitcoin/GetAddress',
            blitskrieg_dot_blitskrieg__pb2.GetAddressRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.GetAddressResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GenTransactions(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, '/blits.Bitcoin/GenTransactions',
            blitskrieg_dot_blitskrieg__pb2.GenTransactionsRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.GenTransactionsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MineBlock(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, '/blits.Bitcoin/MineBlock',
            blitskrieg_dot_blitskrieg__pb2.MineBlockRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.MineBlockResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Send(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, '/blits.Bitcoin/Send',
            blitskrieg_dot_blitskrieg__pb2.SendRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.SendResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.FundNodes = channel.unary_unary(
                '/blits.Lightning/FundNodes',
                request_serializer=blitskrieg_dot_blitskrieg__pb2.FundNodesRequest.SerializeToString,
                response_deserializer=blitskrieg_dot_blitskrieg__pb2.FundNodesResponse.FromString,
                )


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

    def FundNodes(self, request, context):
        """*
        Send BTC to all LN nodes.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_LightningServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'FundNodes': grpc.unary_unary_rpc_method_handler(
                    servicer.FundNodes,
                    request_deserializer=blitskrieg_dot_blitskrieg__pb2.FundNodesRequest.FromString,
                    response_serializer=blitskrieg_dot_blitskrieg__pb2.FundNodesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'blits.Lightning', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def FundNodes(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, '/blits.Lightning/FundNodes',
            blitskrieg_dot_blitskrieg__pb2.FundNodesRequest.SerializeToString,
            blitskrieg_dot_blitskrieg__pb2.FundNodesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
