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

from . import dbrouter_pb2 as dbrouter__pb2

GRPC_GENERATED_VERSION = '1.78.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + ' but the generated code in dbrouter_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Check = channel.unary_unary(
                '/dbrouter.HealthService/Check',
                request_serializer=dbrouter__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.HealthCheckResponse.FromString,
                _registered_method=True)
        self.CheckPostgres = channel.unary_unary(
                '/dbrouter.HealthService/CheckPostgres',
                request_serializer=dbrouter__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ConnectionStatus.FromString,
                _registered_method=True)
        self.CheckMongo = channel.unary_unary(
                '/dbrouter.HealthService/CheckMongo',
                request_serializer=dbrouter__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ConnectionStatus.FromString,
                _registered_method=True)
        self.CheckRedis = channel.unary_unary(
                '/dbrouter.HealthService/CheckRedis',
                request_serializer=dbrouter__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ConnectionStatus.FromString,
                _registered_method=True)


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

    def Check(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 CheckPostgres(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 CheckMongo(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 CheckRedis(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_HealthServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Check': grpc.unary_unary_rpc_method_handler(
                    servicer.Check,
                    request_deserializer=dbrouter__pb2.HealthCheckRequest.FromString,
                    response_serializer=dbrouter__pb2.HealthCheckResponse.SerializeToString,
            ),
            'CheckPostgres': grpc.unary_unary_rpc_method_handler(
                    servicer.CheckPostgres,
                    request_deserializer=dbrouter__pb2.HealthCheckRequest.FromString,
                    response_serializer=dbrouter__pb2.ConnectionStatus.SerializeToString,
            ),
            'CheckMongo': grpc.unary_unary_rpc_method_handler(
                    servicer.CheckMongo,
                    request_deserializer=dbrouter__pb2.HealthCheckRequest.FromString,
                    response_serializer=dbrouter__pb2.ConnectionStatus.SerializeToString,
            ),
            'CheckRedis': grpc.unary_unary_rpc_method_handler(
                    servicer.CheckRedis,
                    request_deserializer=dbrouter__pb2.HealthCheckRequest.FromString,
                    response_serializer=dbrouter__pb2.ConnectionStatus.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'dbrouter.HealthService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('dbrouter.HealthService', rpc_method_handlers)


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

    @staticmethod
    def Check(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,
            '/dbrouter.HealthService/Check',
            dbrouter__pb2.HealthCheckRequest.SerializeToString,
            dbrouter__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CheckPostgres(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,
            '/dbrouter.HealthService/CheckPostgres',
            dbrouter__pb2.HealthCheckRequest.SerializeToString,
            dbrouter__pb2.ConnectionStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CheckMongo(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,
            '/dbrouter.HealthService/CheckMongo',
            dbrouter__pb2.HealthCheckRequest.SerializeToString,
            dbrouter__pb2.ConnectionStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CheckRedis(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,
            '/dbrouter.HealthService/CheckRedis',
            dbrouter__pb2.HealthCheckRequest.SerializeToString,
            dbrouter__pb2.ConnectionStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.ListDatabases = channel.unary_unary(
                '/dbrouter.PostgresService/ListDatabases',
                request_serializer=dbrouter__pb2.ListDatabasesRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ListDatabasesResponse.FromString,
                _registered_method=True)
        self.CreateDatabase = channel.unary_unary(
                '/dbrouter.PostgresService/CreateDatabase',
                request_serializer=dbrouter__pb2.CreateDatabaseRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.CreateDatabaseResponse.FromString,
                _registered_method=True)
        self.ListTables = channel.unary_unary(
                '/dbrouter.PostgresService/ListTables',
                request_serializer=dbrouter__pb2.ListTablesRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ListTablesResponse.FromString,
                _registered_method=True)
        self.ExecuteQuery = channel.unary_unary(
                '/dbrouter.PostgresService/ExecuteQuery',
                request_serializer=dbrouter__pb2.ExecuteQueryRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ExecuteQueryResponse.FromString,
                _registered_method=True)
        self.SelectData = channel.unary_unary(
                '/dbrouter.PostgresService/SelectData',
                request_serializer=dbrouter__pb2.SelectDataRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.SelectDataResponse.FromString,
                _registered_method=True)
        self.InsertData = channel.unary_unary(
                '/dbrouter.PostgresService/InsertData',
                request_serializer=dbrouter__pb2.InsertDataRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.InsertDataResponse.FromString,
                _registered_method=True)
        self.UpdateData = channel.unary_unary(
                '/dbrouter.PostgresService/UpdateData',
                request_serializer=dbrouter__pb2.UpdateDataRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.UpdateDataResponse.FromString,
                _registered_method=True)
        self.DeleteData = channel.unary_unary(
                '/dbrouter.PostgresService/DeleteData',
                request_serializer=dbrouter__pb2.DeleteDataRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.DeleteDataResponse.FromString,
                _registered_method=True)


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

    def ListDatabases(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 CreateDatabase(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 ListTables(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 ExecuteQuery(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 SelectData(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 InsertData(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 UpdateData(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 DeleteData(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_PostgresServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ListDatabases': grpc.unary_unary_rpc_method_handler(
                    servicer.ListDatabases,
                    request_deserializer=dbrouter__pb2.ListDatabasesRequest.FromString,
                    response_serializer=dbrouter__pb2.ListDatabasesResponse.SerializeToString,
            ),
            'CreateDatabase': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDatabase,
                    request_deserializer=dbrouter__pb2.CreateDatabaseRequest.FromString,
                    response_serializer=dbrouter__pb2.CreateDatabaseResponse.SerializeToString,
            ),
            'ListTables': grpc.unary_unary_rpc_method_handler(
                    servicer.ListTables,
                    request_deserializer=dbrouter__pb2.ListTablesRequest.FromString,
                    response_serializer=dbrouter__pb2.ListTablesResponse.SerializeToString,
            ),
            'ExecuteQuery': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteQuery,
                    request_deserializer=dbrouter__pb2.ExecuteQueryRequest.FromString,
                    response_serializer=dbrouter__pb2.ExecuteQueryResponse.SerializeToString,
            ),
            'SelectData': grpc.unary_unary_rpc_method_handler(
                    servicer.SelectData,
                    request_deserializer=dbrouter__pb2.SelectDataRequest.FromString,
                    response_serializer=dbrouter__pb2.SelectDataResponse.SerializeToString,
            ),
            'InsertData': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertData,
                    request_deserializer=dbrouter__pb2.InsertDataRequest.FromString,
                    response_serializer=dbrouter__pb2.InsertDataResponse.SerializeToString,
            ),
            'UpdateData': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateData,
                    request_deserializer=dbrouter__pb2.UpdateDataRequest.FromString,
                    response_serializer=dbrouter__pb2.UpdateDataResponse.SerializeToString,
            ),
            'DeleteData': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteData,
                    request_deserializer=dbrouter__pb2.DeleteDataRequest.FromString,
                    response_serializer=dbrouter__pb2.DeleteDataResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'dbrouter.PostgresService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('dbrouter.PostgresService', rpc_method_handlers)


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

    @staticmethod
    def ListDatabases(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,
            '/dbrouter.PostgresService/ListDatabases',
            dbrouter__pb2.ListDatabasesRequest.SerializeToString,
            dbrouter__pb2.ListDatabasesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateDatabase(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,
            '/dbrouter.PostgresService/CreateDatabase',
            dbrouter__pb2.CreateDatabaseRequest.SerializeToString,
            dbrouter__pb2.CreateDatabaseResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListTables(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,
            '/dbrouter.PostgresService/ListTables',
            dbrouter__pb2.ListTablesRequest.SerializeToString,
            dbrouter__pb2.ListTablesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteQuery(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,
            '/dbrouter.PostgresService/ExecuteQuery',
            dbrouter__pb2.ExecuteQueryRequest.SerializeToString,
            dbrouter__pb2.ExecuteQueryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SelectData(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,
            '/dbrouter.PostgresService/SelectData',
            dbrouter__pb2.SelectDataRequest.SerializeToString,
            dbrouter__pb2.SelectDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InsertData(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,
            '/dbrouter.PostgresService/InsertData',
            dbrouter__pb2.InsertDataRequest.SerializeToString,
            dbrouter__pb2.InsertDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateData(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,
            '/dbrouter.PostgresService/UpdateData',
            dbrouter__pb2.UpdateDataRequest.SerializeToString,
            dbrouter__pb2.UpdateDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteData(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,
            '/dbrouter.PostgresService/DeleteData',
            dbrouter__pb2.DeleteDataRequest.SerializeToString,
            dbrouter__pb2.DeleteDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.ListDatabases = channel.unary_unary(
                '/dbrouter.MongoService/ListDatabases',
                request_serializer=dbrouter__pb2.ListMongoDatabasesRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ListMongoDatabasesResponse.FromString,
                _registered_method=True)
        self.ListCollections = channel.unary_unary(
                '/dbrouter.MongoService/ListCollections',
                request_serializer=dbrouter__pb2.ListCollectionsRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ListCollectionsResponse.FromString,
                _registered_method=True)
        self.InsertDocument = channel.unary_unary(
                '/dbrouter.MongoService/InsertDocument',
                request_serializer=dbrouter__pb2.InsertDocumentRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.InsertDocumentResponse.FromString,
                _registered_method=True)
        self.FindDocuments = channel.unary_unary(
                '/dbrouter.MongoService/FindDocuments',
                request_serializer=dbrouter__pb2.FindDocumentsRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.FindDocumentsResponse.FromString,
                _registered_method=True)
        self.UpdateDocument = channel.unary_unary(
                '/dbrouter.MongoService/UpdateDocument',
                request_serializer=dbrouter__pb2.UpdateDocumentRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.UpdateDocumentResponse.FromString,
                _registered_method=True)
        self.DeleteDocument = channel.unary_unary(
                '/dbrouter.MongoService/DeleteDocument',
                request_serializer=dbrouter__pb2.DeleteDocumentRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.DeleteDocumentResponse.FromString,
                _registered_method=True)


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

    def ListDatabases(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 ListCollections(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 InsertDocument(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 FindDocuments(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 UpdateDocument(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 DeleteDocument(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_MongoServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ListDatabases': grpc.unary_unary_rpc_method_handler(
                    servicer.ListDatabases,
                    request_deserializer=dbrouter__pb2.ListMongoDatabasesRequest.FromString,
                    response_serializer=dbrouter__pb2.ListMongoDatabasesResponse.SerializeToString,
            ),
            'ListCollections': grpc.unary_unary_rpc_method_handler(
                    servicer.ListCollections,
                    request_deserializer=dbrouter__pb2.ListCollectionsRequest.FromString,
                    response_serializer=dbrouter__pb2.ListCollectionsResponse.SerializeToString,
            ),
            'InsertDocument': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertDocument,
                    request_deserializer=dbrouter__pb2.InsertDocumentRequest.FromString,
                    response_serializer=dbrouter__pb2.InsertDocumentResponse.SerializeToString,
            ),
            'FindDocuments': grpc.unary_unary_rpc_method_handler(
                    servicer.FindDocuments,
                    request_deserializer=dbrouter__pb2.FindDocumentsRequest.FromString,
                    response_serializer=dbrouter__pb2.FindDocumentsResponse.SerializeToString,
            ),
            'UpdateDocument': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateDocument,
                    request_deserializer=dbrouter__pb2.UpdateDocumentRequest.FromString,
                    response_serializer=dbrouter__pb2.UpdateDocumentResponse.SerializeToString,
            ),
            'DeleteDocument': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteDocument,
                    request_deserializer=dbrouter__pb2.DeleteDocumentRequest.FromString,
                    response_serializer=dbrouter__pb2.DeleteDocumentResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'dbrouter.MongoService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('dbrouter.MongoService', rpc_method_handlers)


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

    @staticmethod
    def ListDatabases(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,
            '/dbrouter.MongoService/ListDatabases',
            dbrouter__pb2.ListMongoDatabasesRequest.SerializeToString,
            dbrouter__pb2.ListMongoDatabasesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListCollections(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,
            '/dbrouter.MongoService/ListCollections',
            dbrouter__pb2.ListCollectionsRequest.SerializeToString,
            dbrouter__pb2.ListCollectionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InsertDocument(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,
            '/dbrouter.MongoService/InsertDocument',
            dbrouter__pb2.InsertDocumentRequest.SerializeToString,
            dbrouter__pb2.InsertDocumentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FindDocuments(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,
            '/dbrouter.MongoService/FindDocuments',
            dbrouter__pb2.FindDocumentsRequest.SerializeToString,
            dbrouter__pb2.FindDocumentsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateDocument(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,
            '/dbrouter.MongoService/UpdateDocument',
            dbrouter__pb2.UpdateDocumentRequest.SerializeToString,
            dbrouter__pb2.UpdateDocumentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteDocument(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,
            '/dbrouter.MongoService/DeleteDocument',
            dbrouter__pb2.DeleteDocumentRequest.SerializeToString,
            dbrouter__pb2.DeleteDocumentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.ListKeys = channel.unary_unary(
                '/dbrouter.RedisService/ListKeys',
                request_serializer=dbrouter__pb2.ListKeysRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.ListKeysResponse.FromString,
                _registered_method=True)
        self.SetValue = channel.unary_unary(
                '/dbrouter.RedisService/SetValue',
                request_serializer=dbrouter__pb2.SetValueRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.SetValueResponse.FromString,
                _registered_method=True)
        self.GetValue = channel.unary_unary(
                '/dbrouter.RedisService/GetValue',
                request_serializer=dbrouter__pb2.GetValueRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.GetValueResponse.FromString,
                _registered_method=True)
        self.DeleteKey = channel.unary_unary(
                '/dbrouter.RedisService/DeleteKey',
                request_serializer=dbrouter__pb2.DeleteKeyRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.DeleteKeyResponse.FromString,
                _registered_method=True)
        self.Info = channel.unary_unary(
                '/dbrouter.RedisService/Info',
                request_serializer=dbrouter__pb2.RedisInfoRequest.SerializeToString,
                response_deserializer=dbrouter__pb2.RedisInfoResponse.FromString,
                _registered_method=True)


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

    def ListKeys(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 SetValue(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 GetValue(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 DeleteKey(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 Info(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_RedisServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ListKeys': grpc.unary_unary_rpc_method_handler(
                    servicer.ListKeys,
                    request_deserializer=dbrouter__pb2.ListKeysRequest.FromString,
                    response_serializer=dbrouter__pb2.ListKeysResponse.SerializeToString,
            ),
            'SetValue': grpc.unary_unary_rpc_method_handler(
                    servicer.SetValue,
                    request_deserializer=dbrouter__pb2.SetValueRequest.FromString,
                    response_serializer=dbrouter__pb2.SetValueResponse.SerializeToString,
            ),
            'GetValue': grpc.unary_unary_rpc_method_handler(
                    servicer.GetValue,
                    request_deserializer=dbrouter__pb2.GetValueRequest.FromString,
                    response_serializer=dbrouter__pb2.GetValueResponse.SerializeToString,
            ),
            'DeleteKey': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteKey,
                    request_deserializer=dbrouter__pb2.DeleteKeyRequest.FromString,
                    response_serializer=dbrouter__pb2.DeleteKeyResponse.SerializeToString,
            ),
            'Info': grpc.unary_unary_rpc_method_handler(
                    servicer.Info,
                    request_deserializer=dbrouter__pb2.RedisInfoRequest.FromString,
                    response_serializer=dbrouter__pb2.RedisInfoResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'dbrouter.RedisService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('dbrouter.RedisService', rpc_method_handlers)


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

    @staticmethod
    def ListKeys(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,
            '/dbrouter.RedisService/ListKeys',
            dbrouter__pb2.ListKeysRequest.SerializeToString,
            dbrouter__pb2.ListKeysResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetValue(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,
            '/dbrouter.RedisService/SetValue',
            dbrouter__pb2.SetValueRequest.SerializeToString,
            dbrouter__pb2.SetValueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetValue(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,
            '/dbrouter.RedisService/GetValue',
            dbrouter__pb2.GetValueRequest.SerializeToString,
            dbrouter__pb2.GetValueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteKey(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,
            '/dbrouter.RedisService/DeleteKey',
            dbrouter__pb2.DeleteKeyRequest.SerializeToString,
            dbrouter__pb2.DeleteKeyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Info(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,
            '/dbrouter.RedisService/Info',
            dbrouter__pb2.RedisInfoRequest.SerializeToString,
            dbrouter__pb2.RedisInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
