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

from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
from . import lc_pb2 as lc__pb2
from . import schema_pb2 as schema__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Set = channel.unary_unary(
                '/lc.schema.LcService/Set',
                request_serializer=schema__pb2.SetRequest.SerializeToString,
                response_deserializer=schema__pb2.TxMetadata.FromString,
                )
        self.Get = channel.unary_unary(
                '/lc.schema.LcService/Get',
                request_serializer=schema__pb2.KeyRequest.SerializeToString,
                response_deserializer=schema__pb2.Entry.FromString,
                )
        self.VerifiableSet = channel.unary_unary(
                '/lc.schema.LcService/VerifiableSet',
                request_serializer=schema__pb2.VerifiableSetRequest.SerializeToString,
                response_deserializer=schema__pb2.VerifiableTx.FromString,
                )
        self.VerifiableGet = channel.unary_unary(
                '/lc.schema.LcService/VerifiableGet',
                request_serializer=schema__pb2.VerifiableGetRequest.SerializeToString,
                response_deserializer=schema__pb2.VerifiableEntry.FromString,
                )
        self.GetAll = channel.unary_unary(
                '/lc.schema.LcService/GetAll',
                request_serializer=schema__pb2.KeyListRequest.SerializeToString,
                response_deserializer=schema__pb2.Entries.FromString,
                )
        self.ExecAll = channel.unary_unary(
                '/lc.schema.LcService/ExecAll',
                request_serializer=schema__pb2.ExecAllRequest.SerializeToString,
                response_deserializer=schema__pb2.TxMetadata.FromString,
                )
        self.Scan = channel.unary_unary(
                '/lc.schema.LcService/Scan',
                request_serializer=schema__pb2.ScanRequest.SerializeToString,
                response_deserializer=schema__pb2.Entries.FromString,
                )
        self.History = channel.unary_unary(
                '/lc.schema.LcService/History',
                request_serializer=schema__pb2.HistoryRequest.SerializeToString,
                response_deserializer=schema__pb2.Entries.FromString,
                )
        self.ZAdd = channel.unary_unary(
                '/lc.schema.LcService/ZAdd',
                request_serializer=schema__pb2.ZAddRequest.SerializeToString,
                response_deserializer=schema__pb2.TxMetadata.FromString,
                )
        self.VerifiableZAdd = channel.unary_unary(
                '/lc.schema.LcService/VerifiableZAdd',
                request_serializer=schema__pb2.VerifiableZAddRequest.SerializeToString,
                response_deserializer=schema__pb2.VerifiableTx.FromString,
                )
        self.ZScan = channel.unary_unary(
                '/lc.schema.LcService/ZScan',
                request_serializer=schema__pb2.ZScanRequest.SerializeToString,
                response_deserializer=schema__pb2.ZEntries.FromString,
                )
        self.CurrentState = channel.unary_unary(
                '/lc.schema.LcService/CurrentState',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=schema__pb2.ImmutableState.FromString,
                )
        self.Health = channel.unary_unary(
                '/lc.schema.LcService/Health',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=schema__pb2.HealthResponse.FromString,
                )
        self.ReportTamper = channel.unary_unary(
                '/lc.schema.LcService/ReportTamper',
                request_serializer=lc__pb2.ReportOptions.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.SendData = channel.stream_stream(
                '/lc.schema.LcService/SendData',
                request_serializer=lc__pb2.Data.SerializeToString,
                response_deserializer=lc__pb2.Response.FromString,
                )
        self.VerifiableGetExt = channel.unary_unary(
                '/lc.schema.LcService/VerifiableGetExt',
                request_serializer=schema__pb2.VerifiableGetRequest.SerializeToString,
                response_deserializer=lc__pb2.VerifiableItemExt.FromString,
                )
        self.ZScanExt = channel.unary_unary(
                '/lc.schema.LcService/ZScanExt',
                request_serializer=schema__pb2.ZScanRequest.SerializeToString,
                response_deserializer=lc__pb2.ZItemExtList.FromString,
                )
        self.HistoryExt = channel.unary_unary(
                '/lc.schema.LcService/HistoryExt',
                request_serializer=schema__pb2.HistoryRequest.SerializeToString,
                response_deserializer=lc__pb2.ItemExtList.FromString,
                )


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

    def Set(self, request, context):
        """immudb primitives
        setters and getters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Get(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 VerifiableSet(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 VerifiableGet(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 GetAll(self, request, context):
        """batch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecAll(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 Scan(self, request, context):
        """scanners
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def History(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 ZAdd(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 VerifiableZAdd(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 ZScan(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 CurrentState(self, request, context):
        """mixed
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Health(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 ReportTamper(self, request, context):
        """ledger compliance extensions
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendData(self, request_iterator, 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 VerifiableGetExt(self, request, context):
        """ledger compliance extensions - items extended with additional properties managed by LC backend (date)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ZScanExt(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 HistoryExt(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_LcServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Set': grpc.unary_unary_rpc_method_handler(
                    servicer.Set,
                    request_deserializer=schema__pb2.SetRequest.FromString,
                    response_serializer=schema__pb2.TxMetadata.SerializeToString,
            ),
            'Get': grpc.unary_unary_rpc_method_handler(
                    servicer.Get,
                    request_deserializer=schema__pb2.KeyRequest.FromString,
                    response_serializer=schema__pb2.Entry.SerializeToString,
            ),
            'VerifiableSet': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifiableSet,
                    request_deserializer=schema__pb2.VerifiableSetRequest.FromString,
                    response_serializer=schema__pb2.VerifiableTx.SerializeToString,
            ),
            'VerifiableGet': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifiableGet,
                    request_deserializer=schema__pb2.VerifiableGetRequest.FromString,
                    response_serializer=schema__pb2.VerifiableEntry.SerializeToString,
            ),
            'GetAll': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAll,
                    request_deserializer=schema__pb2.KeyListRequest.FromString,
                    response_serializer=schema__pb2.Entries.SerializeToString,
            ),
            'ExecAll': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecAll,
                    request_deserializer=schema__pb2.ExecAllRequest.FromString,
                    response_serializer=schema__pb2.TxMetadata.SerializeToString,
            ),
            'Scan': grpc.unary_unary_rpc_method_handler(
                    servicer.Scan,
                    request_deserializer=schema__pb2.ScanRequest.FromString,
                    response_serializer=schema__pb2.Entries.SerializeToString,
            ),
            'History': grpc.unary_unary_rpc_method_handler(
                    servicer.History,
                    request_deserializer=schema__pb2.HistoryRequest.FromString,
                    response_serializer=schema__pb2.Entries.SerializeToString,
            ),
            'ZAdd': grpc.unary_unary_rpc_method_handler(
                    servicer.ZAdd,
                    request_deserializer=schema__pb2.ZAddRequest.FromString,
                    response_serializer=schema__pb2.TxMetadata.SerializeToString,
            ),
            'VerifiableZAdd': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifiableZAdd,
                    request_deserializer=schema__pb2.VerifiableZAddRequest.FromString,
                    response_serializer=schema__pb2.VerifiableTx.SerializeToString,
            ),
            'ZScan': grpc.unary_unary_rpc_method_handler(
                    servicer.ZScan,
                    request_deserializer=schema__pb2.ZScanRequest.FromString,
                    response_serializer=schema__pb2.ZEntries.SerializeToString,
            ),
            'CurrentState': grpc.unary_unary_rpc_method_handler(
                    servicer.CurrentState,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=schema__pb2.ImmutableState.SerializeToString,
            ),
            'Health': grpc.unary_unary_rpc_method_handler(
                    servicer.Health,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=schema__pb2.HealthResponse.SerializeToString,
            ),
            'ReportTamper': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportTamper,
                    request_deserializer=lc__pb2.ReportOptions.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'SendData': grpc.stream_stream_rpc_method_handler(
                    servicer.SendData,
                    request_deserializer=lc__pb2.Data.FromString,
                    response_serializer=lc__pb2.Response.SerializeToString,
            ),
            'VerifiableGetExt': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifiableGetExt,
                    request_deserializer=schema__pb2.VerifiableGetRequest.FromString,
                    response_serializer=lc__pb2.VerifiableItemExt.SerializeToString,
            ),
            'ZScanExt': grpc.unary_unary_rpc_method_handler(
                    servicer.ZScanExt,
                    request_deserializer=schema__pb2.ZScanRequest.FromString,
                    response_serializer=lc__pb2.ZItemExtList.SerializeToString,
            ),
            'HistoryExt': grpc.unary_unary_rpc_method_handler(
                    servicer.HistoryExt,
                    request_deserializer=schema__pb2.HistoryRequest.FromString,
                    response_serializer=lc__pb2.ItemExtList.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'lc.schema.LcService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def Set(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, '/lc.schema.LcService/Set',
            schema__pb2.SetRequest.SerializeToString,
            schema__pb2.TxMetadata.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Get(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, '/lc.schema.LcService/Get',
            schema__pb2.KeyRequest.SerializeToString,
            schema__pb2.Entry.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def VerifiableSet(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, '/lc.schema.LcService/VerifiableSet',
            schema__pb2.VerifiableSetRequest.SerializeToString,
            schema__pb2.VerifiableTx.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def VerifiableGet(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, '/lc.schema.LcService/VerifiableGet',
            schema__pb2.VerifiableGetRequest.SerializeToString,
            schema__pb2.VerifiableEntry.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetAll(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, '/lc.schema.LcService/GetAll',
            schema__pb2.KeyListRequest.SerializeToString,
            schema__pb2.Entries.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ExecAll(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, '/lc.schema.LcService/ExecAll',
            schema__pb2.ExecAllRequest.SerializeToString,
            schema__pb2.TxMetadata.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Scan(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, '/lc.schema.LcService/Scan',
            schema__pb2.ScanRequest.SerializeToString,
            schema__pb2.Entries.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def History(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, '/lc.schema.LcService/History',
            schema__pb2.HistoryRequest.SerializeToString,
            schema__pb2.Entries.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ZAdd(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, '/lc.schema.LcService/ZAdd',
            schema__pb2.ZAddRequest.SerializeToString,
            schema__pb2.TxMetadata.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def VerifiableZAdd(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, '/lc.schema.LcService/VerifiableZAdd',
            schema__pb2.VerifiableZAddRequest.SerializeToString,
            schema__pb2.VerifiableTx.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ZScan(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, '/lc.schema.LcService/ZScan',
            schema__pb2.ZScanRequest.SerializeToString,
            schema__pb2.ZEntries.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CurrentState(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, '/lc.schema.LcService/CurrentState',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            schema__pb2.ImmutableState.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Health(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, '/lc.schema.LcService/Health',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            schema__pb2.HealthResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReportTamper(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, '/lc.schema.LcService/ReportTamper',
            lc__pb2.ReportOptions.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendData(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, '/lc.schema.LcService/SendData',
            lc__pb2.Data.SerializeToString,
            lc__pb2.Response.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def VerifiableGetExt(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, '/lc.schema.LcService/VerifiableGetExt',
            schema__pb2.VerifiableGetRequest.SerializeToString,
            lc__pb2.VerifiableItemExt.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ZScanExt(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, '/lc.schema.LcService/ZScanExt',
            schema__pb2.ZScanRequest.SerializeToString,
            lc__pb2.ZItemExtList.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def HistoryExt(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, '/lc.schema.LcService/HistoryExt',
            schema__pb2.HistoryRequest.SerializeToString,
            lc__pb2.ItemExtList.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
