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

import gqldb_pb2 as gqldb__pb2

GRPC_GENERATED_VERSION = '1.76.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 gqldb_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 SessionServiceStub(object):
    """=============================================================================
    Session Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Login = channel.unary_unary(
                '/gqldb.SessionService/Login',
                request_serializer=gqldb__pb2.LoginRequest.SerializeToString,
                response_deserializer=gqldb__pb2.LoginResponse.FromString,
                _registered_method=True)
        self.Logout = channel.unary_unary(
                '/gqldb.SessionService/Logout',
                request_serializer=gqldb__pb2.LogoutRequest.SerializeToString,
                response_deserializer=gqldb__pb2.LogoutResponse.FromString,
                _registered_method=True)
        self.Ping = channel.unary_unary(
                '/gqldb.SessionService/Ping',
                request_serializer=gqldb__pb2.PingRequest.SerializeToString,
                response_deserializer=gqldb__pb2.PingResponse.FromString,
                _registered_method=True)


class SessionServiceServicer(object):
    """=============================================================================
    Session Service
    =============================================================================

    """

    def Login(self, request, context):
        """Login authenticates a user and creates a session.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Logout(self, request, context):
        """Logout terminates a session.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Ping(self, request, context):
        """Ping keeps a session alive and checks connectivity.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_SessionServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Login': grpc.unary_unary_rpc_method_handler(
                    servicer.Login,
                    request_deserializer=gqldb__pb2.LoginRequest.FromString,
                    response_serializer=gqldb__pb2.LoginResponse.SerializeToString,
            ),
            'Logout': grpc.unary_unary_rpc_method_handler(
                    servicer.Logout,
                    request_deserializer=gqldb__pb2.LogoutRequest.FromString,
                    response_serializer=gqldb__pb2.LogoutResponse.SerializeToString,
            ),
            'Ping': grpc.unary_unary_rpc_method_handler(
                    servicer.Ping,
                    request_deserializer=gqldb__pb2.PingRequest.FromString,
                    response_serializer=gqldb__pb2.PingResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.SessionService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.SessionService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class SessionService(object):
    """=============================================================================
    Session Service
    =============================================================================

    """

    @staticmethod
    def Login(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,
            '/gqldb.SessionService/Login',
            gqldb__pb2.LoginRequest.SerializeToString,
            gqldb__pb2.LoginResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Logout(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,
            '/gqldb.SessionService/Logout',
            gqldb__pb2.LogoutRequest.SerializeToString,
            gqldb__pb2.LogoutResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Ping(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,
            '/gqldb.SessionService/Ping',
            gqldb__pb2.PingRequest.SerializeToString,
            gqldb__pb2.PingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class QueryServiceStub(object):
    """=============================================================================
    Query Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Gql = channel.unary_unary(
                '/gqldb.QueryService/Gql',
                request_serializer=gqldb__pb2.GqlRequest.SerializeToString,
                response_deserializer=gqldb__pb2.GqlResponse.FromString,
                _registered_method=True)
        self.GqlStream = channel.unary_stream(
                '/gqldb.QueryService/GqlStream',
                request_serializer=gqldb__pb2.GqlRequest.SerializeToString,
                response_deserializer=gqldb__pb2.GqlResponse.FromString,
                _registered_method=True)
        self.GqlStatement = channel.unary_unary(
                '/gqldb.QueryService/GqlStatement',
                request_serializer=gqldb__pb2.GqlRequest.SerializeToString,
                response_deserializer=gqldb__pb2.StatementResult.FromString,
                _registered_method=True)
        self.Explain = channel.unary_unary(
                '/gqldb.QueryService/Explain',
                request_serializer=gqldb__pb2.GqlRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ExplainResponse.FromString,
                _registered_method=True)
        self.Profile = channel.unary_unary(
                '/gqldb.QueryService/Profile',
                request_serializer=gqldb__pb2.GqlRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ProfileResponse.FromString,
                _registered_method=True)


class QueryServiceServicer(object):
    """=============================================================================
    Query Service
    =============================================================================

    """

    def Gql(self, request, context):
        """Gql executes a GQL query and returns results.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GqlStream(self, request, context):
        """GqlStream executes a GQL query and streams results.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GqlStatement(self, request, context):
        """GqlStatement executes a GQL statement (DDL/DML) and returns status.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Explain(self, request, context):
        """Explain returns the execution plan for a query.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Profile(self, request, context):
        """Profile executes a query with profiling and returns statistics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_QueryServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Gql': grpc.unary_unary_rpc_method_handler(
                    servicer.Gql,
                    request_deserializer=gqldb__pb2.GqlRequest.FromString,
                    response_serializer=gqldb__pb2.GqlResponse.SerializeToString,
            ),
            'GqlStream': grpc.unary_stream_rpc_method_handler(
                    servicer.GqlStream,
                    request_deserializer=gqldb__pb2.GqlRequest.FromString,
                    response_serializer=gqldb__pb2.GqlResponse.SerializeToString,
            ),
            'GqlStatement': grpc.unary_unary_rpc_method_handler(
                    servicer.GqlStatement,
                    request_deserializer=gqldb__pb2.GqlRequest.FromString,
                    response_serializer=gqldb__pb2.StatementResult.SerializeToString,
            ),
            'Explain': grpc.unary_unary_rpc_method_handler(
                    servicer.Explain,
                    request_deserializer=gqldb__pb2.GqlRequest.FromString,
                    response_serializer=gqldb__pb2.ExplainResponse.SerializeToString,
            ),
            'Profile': grpc.unary_unary_rpc_method_handler(
                    servicer.Profile,
                    request_deserializer=gqldb__pb2.GqlRequest.FromString,
                    response_serializer=gqldb__pb2.ProfileResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.QueryService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.QueryService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class QueryService(object):
    """=============================================================================
    Query Service
    =============================================================================

    """

    @staticmethod
    def Gql(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,
            '/gqldb.QueryService/Gql',
            gqldb__pb2.GqlRequest.SerializeToString,
            gqldb__pb2.GqlResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GqlStream(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/gqldb.QueryService/GqlStream',
            gqldb__pb2.GqlRequest.SerializeToString,
            gqldb__pb2.GqlResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GqlStatement(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,
            '/gqldb.QueryService/GqlStatement',
            gqldb__pb2.GqlRequest.SerializeToString,
            gqldb__pb2.StatementResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Explain(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,
            '/gqldb.QueryService/Explain',
            gqldb__pb2.GqlRequest.SerializeToString,
            gqldb__pb2.ExplainResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Profile(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,
            '/gqldb.QueryService/Profile',
            gqldb__pb2.GqlRequest.SerializeToString,
            gqldb__pb2.ProfileResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class DataServiceStub(object):
    """=============================================================================
    Data Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.InsertNodes = channel.unary_unary(
                '/gqldb.DataService/InsertNodes',
                request_serializer=gqldb__pb2.InsertNodesRequest.SerializeToString,
                response_deserializer=gqldb__pb2.InsertNodesResponse.FromString,
                _registered_method=True)
        self.InsertEdges = channel.unary_unary(
                '/gqldb.DataService/InsertEdges',
                request_serializer=gqldb__pb2.InsertEdgesRequest.SerializeToString,
                response_deserializer=gqldb__pb2.InsertEdgesResponse.FromString,
                _registered_method=True)
        self.DeleteNodes = channel.unary_unary(
                '/gqldb.DataService/DeleteNodes',
                request_serializer=gqldb__pb2.DeleteNodesRequest.SerializeToString,
                response_deserializer=gqldb__pb2.DeleteNodesResponse.FromString,
                _registered_method=True)
        self.DeleteEdges = channel.unary_unary(
                '/gqldb.DataService/DeleteEdges',
                request_serializer=gqldb__pb2.DeleteEdgesRequest.SerializeToString,
                response_deserializer=gqldb__pb2.DeleteEdgesResponse.FromString,
                _registered_method=True)
        self.ExportNodes = channel.unary_stream(
                '/gqldb.DataService/ExportNodes',
                request_serializer=gqldb__pb2.ExportNodesRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ExportNodesResponse.FromString,
                _registered_method=True)
        self.ExportEdges = channel.unary_stream(
                '/gqldb.DataService/ExportEdges',
                request_serializer=gqldb__pb2.ExportEdgesRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ExportEdgesResponse.FromString,
                _registered_method=True)


class DataServiceServicer(object):
    """=============================================================================
    Data Service
    =============================================================================

    """

    def InsertNodes(self, request, context):
        """InsertNodes inserts multiple nodes into a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InsertEdges(self, request, context):
        """InsertEdges inserts multiple edges into a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteNodes(self, request, context):
        """DeleteNodes deletes nodes from a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteEdges(self, request, context):
        """DeleteEdges deletes edges from a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExportNodes(self, request, context):
        """ExportNodes streams nodes from a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExportEdges(self, request, context):
        """ExportEdges streams edges from a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DataServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'InsertNodes': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertNodes,
                    request_deserializer=gqldb__pb2.InsertNodesRequest.FromString,
                    response_serializer=gqldb__pb2.InsertNodesResponse.SerializeToString,
            ),
            'InsertEdges': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertEdges,
                    request_deserializer=gqldb__pb2.InsertEdgesRequest.FromString,
                    response_serializer=gqldb__pb2.InsertEdgesResponse.SerializeToString,
            ),
            'DeleteNodes': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteNodes,
                    request_deserializer=gqldb__pb2.DeleteNodesRequest.FromString,
                    response_serializer=gqldb__pb2.DeleteNodesResponse.SerializeToString,
            ),
            'DeleteEdges': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteEdges,
                    request_deserializer=gqldb__pb2.DeleteEdgesRequest.FromString,
                    response_serializer=gqldb__pb2.DeleteEdgesResponse.SerializeToString,
            ),
            'ExportNodes': grpc.unary_stream_rpc_method_handler(
                    servicer.ExportNodes,
                    request_deserializer=gqldb__pb2.ExportNodesRequest.FromString,
                    response_serializer=gqldb__pb2.ExportNodesResponse.SerializeToString,
            ),
            'ExportEdges': grpc.unary_stream_rpc_method_handler(
                    servicer.ExportEdges,
                    request_deserializer=gqldb__pb2.ExportEdgesRequest.FromString,
                    response_serializer=gqldb__pb2.ExportEdgesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.DataService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.DataService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class DataService(object):
    """=============================================================================
    Data Service
    =============================================================================

    """

    @staticmethod
    def InsertNodes(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,
            '/gqldb.DataService/InsertNodes',
            gqldb__pb2.InsertNodesRequest.SerializeToString,
            gqldb__pb2.InsertNodesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InsertEdges(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,
            '/gqldb.DataService/InsertEdges',
            gqldb__pb2.InsertEdgesRequest.SerializeToString,
            gqldb__pb2.InsertEdgesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteNodes(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,
            '/gqldb.DataService/DeleteNodes',
            gqldb__pb2.DeleteNodesRequest.SerializeToString,
            gqldb__pb2.DeleteNodesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteEdges(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,
            '/gqldb.DataService/DeleteEdges',
            gqldb__pb2.DeleteEdgesRequest.SerializeToString,
            gqldb__pb2.DeleteEdgesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExportNodes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/gqldb.DataService/ExportNodes',
            gqldb__pb2.ExportNodesRequest.SerializeToString,
            gqldb__pb2.ExportNodesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExportEdges(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/gqldb.DataService/ExportEdges',
            gqldb__pb2.ExportEdgesRequest.SerializeToString,
            gqldb__pb2.ExportEdgesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class GraphServiceStub(object):
    """=============================================================================
    Graph Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateGraph = channel.unary_unary(
                '/gqldb.GraphService/CreateGraph',
                request_serializer=gqldb__pb2.CreateGraphRequest.SerializeToString,
                response_deserializer=gqldb__pb2.CreateGraphResponse.FromString,
                _registered_method=True)
        self.DropGraph = channel.unary_unary(
                '/gqldb.GraphService/DropGraph',
                request_serializer=gqldb__pb2.DropGraphRequest.SerializeToString,
                response_deserializer=gqldb__pb2.DropGraphResponse.FromString,
                _registered_method=True)
        self.UseGraph = channel.unary_unary(
                '/gqldb.GraphService/UseGraph',
                request_serializer=gqldb__pb2.UseGraphRequest.SerializeToString,
                response_deserializer=gqldb__pb2.UseGraphResponse.FromString,
                _registered_method=True)
        self.ListGraphs = channel.unary_unary(
                '/gqldb.GraphService/ListGraphs',
                request_serializer=gqldb__pb2.ListGraphsRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ListGraphsResponse.FromString,
                _registered_method=True)
        self.GetGraphInfo = channel.unary_unary(
                '/gqldb.GraphService/GetGraphInfo',
                request_serializer=gqldb__pb2.GetGraphInfoRequest.SerializeToString,
                response_deserializer=gqldb__pb2.GetGraphInfoResponse.FromString,
                _registered_method=True)


class GraphServiceServicer(object):
    """=============================================================================
    Graph Service
    =============================================================================

    """

    def CreateGraph(self, request, context):
        """CreateGraph creates a new graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropGraph(self, request, context):
        """DropGraph deletes a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UseGraph(self, request, context):
        """UseGraph sets the current graph for a session.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListGraphs(self, request, context):
        """ListGraphs returns all available graphs.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetGraphInfo(self, request, context):
        """GetGraphInfo returns detailed information about a graph.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_GraphServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateGraph': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateGraph,
                    request_deserializer=gqldb__pb2.CreateGraphRequest.FromString,
                    response_serializer=gqldb__pb2.CreateGraphResponse.SerializeToString,
            ),
            'DropGraph': grpc.unary_unary_rpc_method_handler(
                    servicer.DropGraph,
                    request_deserializer=gqldb__pb2.DropGraphRequest.FromString,
                    response_serializer=gqldb__pb2.DropGraphResponse.SerializeToString,
            ),
            'UseGraph': grpc.unary_unary_rpc_method_handler(
                    servicer.UseGraph,
                    request_deserializer=gqldb__pb2.UseGraphRequest.FromString,
                    response_serializer=gqldb__pb2.UseGraphResponse.SerializeToString,
            ),
            'ListGraphs': grpc.unary_unary_rpc_method_handler(
                    servicer.ListGraphs,
                    request_deserializer=gqldb__pb2.ListGraphsRequest.FromString,
                    response_serializer=gqldb__pb2.ListGraphsResponse.SerializeToString,
            ),
            'GetGraphInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetGraphInfo,
                    request_deserializer=gqldb__pb2.GetGraphInfoRequest.FromString,
                    response_serializer=gqldb__pb2.GetGraphInfoResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.GraphService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.GraphService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class GraphService(object):
    """=============================================================================
    Graph Service
    =============================================================================

    """

    @staticmethod
    def CreateGraph(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,
            '/gqldb.GraphService/CreateGraph',
            gqldb__pb2.CreateGraphRequest.SerializeToString,
            gqldb__pb2.CreateGraphResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DropGraph(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,
            '/gqldb.GraphService/DropGraph',
            gqldb__pb2.DropGraphRequest.SerializeToString,
            gqldb__pb2.DropGraphResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UseGraph(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,
            '/gqldb.GraphService/UseGraph',
            gqldb__pb2.UseGraphRequest.SerializeToString,
            gqldb__pb2.UseGraphResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListGraphs(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,
            '/gqldb.GraphService/ListGraphs',
            gqldb__pb2.ListGraphsRequest.SerializeToString,
            gqldb__pb2.ListGraphsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetGraphInfo(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,
            '/gqldb.GraphService/GetGraphInfo',
            gqldb__pb2.GetGraphInfoRequest.SerializeToString,
            gqldb__pb2.GetGraphInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class TransactionServiceStub(object):
    """=============================================================================
    Transaction Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Begin = channel.unary_unary(
                '/gqldb.TransactionService/Begin',
                request_serializer=gqldb__pb2.BeginRequest.SerializeToString,
                response_deserializer=gqldb__pb2.BeginResponse.FromString,
                _registered_method=True)
        self.Commit = channel.unary_unary(
                '/gqldb.TransactionService/Commit',
                request_serializer=gqldb__pb2.CommitRequest.SerializeToString,
                response_deserializer=gqldb__pb2.CommitResponse.FromString,
                _registered_method=True)
        self.Rollback = channel.unary_unary(
                '/gqldb.TransactionService/Rollback',
                request_serializer=gqldb__pb2.RollbackRequest.SerializeToString,
                response_deserializer=gqldb__pb2.RollbackResponse.FromString,
                _registered_method=True)
        self.ListTransactions = channel.unary_unary(
                '/gqldb.TransactionService/ListTransactions',
                request_serializer=gqldb__pb2.ListTransactionsRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ListTransactionsResponse.FromString,
                _registered_method=True)


class TransactionServiceServicer(object):
    """=============================================================================
    Transaction Service
    =============================================================================

    """

    def Begin(self, request, context):
        """Begin starts a new transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Commit(self, request, context):
        """Commit commits a transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Rollback(self, request, context):
        """Rollback aborts a transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListTransactions(self, request, context):
        """ListTransactions returns active transactions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TransactionServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Begin': grpc.unary_unary_rpc_method_handler(
                    servicer.Begin,
                    request_deserializer=gqldb__pb2.BeginRequest.FromString,
                    response_serializer=gqldb__pb2.BeginResponse.SerializeToString,
            ),
            'Commit': grpc.unary_unary_rpc_method_handler(
                    servicer.Commit,
                    request_deserializer=gqldb__pb2.CommitRequest.FromString,
                    response_serializer=gqldb__pb2.CommitResponse.SerializeToString,
            ),
            'Rollback': grpc.unary_unary_rpc_method_handler(
                    servicer.Rollback,
                    request_deserializer=gqldb__pb2.RollbackRequest.FromString,
                    response_serializer=gqldb__pb2.RollbackResponse.SerializeToString,
            ),
            'ListTransactions': grpc.unary_unary_rpc_method_handler(
                    servicer.ListTransactions,
                    request_deserializer=gqldb__pb2.ListTransactionsRequest.FromString,
                    response_serializer=gqldb__pb2.ListTransactionsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.TransactionService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.TransactionService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class TransactionService(object):
    """=============================================================================
    Transaction Service
    =============================================================================

    """

    @staticmethod
    def Begin(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,
            '/gqldb.TransactionService/Begin',
            gqldb__pb2.BeginRequest.SerializeToString,
            gqldb__pb2.BeginResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Commit(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,
            '/gqldb.TransactionService/Commit',
            gqldb__pb2.CommitRequest.SerializeToString,
            gqldb__pb2.CommitResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Rollback(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,
            '/gqldb.TransactionService/Rollback',
            gqldb__pb2.RollbackRequest.SerializeToString,
            gqldb__pb2.RollbackResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListTransactions(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,
            '/gqldb.TransactionService/ListTransactions',
            gqldb__pb2.ListTransactionsRequest.SerializeToString,
            gqldb__pb2.ListTransactionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class HealthStub(object):
    """=============================================================================
    Health Service (gRPC Health Checking Protocol)
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Check = channel.unary_unary(
                '/gqldb.Health/Check',
                request_serializer=gqldb__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=gqldb__pb2.HealthCheckResponse.FromString,
                _registered_method=True)
        self.Watch = channel.unary_stream(
                '/gqldb.Health/Watch',
                request_serializer=gqldb__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=gqldb__pb2.HealthCheckResponse.FromString,
                _registered_method=True)


class HealthServicer(object):
    """=============================================================================
    Health Service (gRPC Health Checking Protocol)
    =============================================================================

    """

    def Check(self, request, context):
        """Check returns the serving status of the service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Watch(self, request, context):
        """Watch streams serving status changes.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_HealthServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Check': grpc.unary_unary_rpc_method_handler(
                    servicer.Check,
                    request_deserializer=gqldb__pb2.HealthCheckRequest.FromString,
                    response_serializer=gqldb__pb2.HealthCheckResponse.SerializeToString,
            ),
            'Watch': grpc.unary_stream_rpc_method_handler(
                    servicer.Watch,
                    request_deserializer=gqldb__pb2.HealthCheckRequest.FromString,
                    response_serializer=gqldb__pb2.HealthCheckResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.Health', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.Health', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Health(object):
    """=============================================================================
    Health Service (gRPC Health Checking Protocol)
    =============================================================================

    """

    @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,
            '/gqldb.Health/Check',
            gqldb__pb2.HealthCheckRequest.SerializeToString,
            gqldb__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Watch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/gqldb.Health/Watch',
            gqldb__pb2.HealthCheckRequest.SerializeToString,
            gqldb__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class AdminServiceStub(object):
    """=============================================================================
    Admin Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.WarmupParser = channel.unary_unary(
                '/gqldb.AdminService/WarmupParser',
                request_serializer=gqldb__pb2.WarmupParserRequest.SerializeToString,
                response_deserializer=gqldb__pb2.WarmupParserResponse.FromString,
                _registered_method=True)
        self.GetCacheStats = channel.unary_unary(
                '/gqldb.AdminService/GetCacheStats',
                request_serializer=gqldb__pb2.GetCacheStatsRequest.SerializeToString,
                response_deserializer=gqldb__pb2.CacheStatsResponse.FromString,
                _registered_method=True)
        self.ClearCache = channel.unary_unary(
                '/gqldb.AdminService/ClearCache',
                request_serializer=gqldb__pb2.ClearCacheRequest.SerializeToString,
                response_deserializer=gqldb__pb2.ClearCacheResponse.FromString,
                _registered_method=True)
        self.GetStatistics = channel.unary_unary(
                '/gqldb.AdminService/GetStatistics',
                request_serializer=gqldb__pb2.GetStatisticsRequest.SerializeToString,
                response_deserializer=gqldb__pb2.GetStatisticsResponse.FromString,
                _registered_method=True)
        self.InvalidatePermissionCache = channel.unary_unary(
                '/gqldb.AdminService/InvalidatePermissionCache',
                request_serializer=gqldb__pb2.InvalidatePermissionCacheRequest.SerializeToString,
                response_deserializer=gqldb__pb2.InvalidatePermissionCacheResponse.FromString,
                _registered_method=True)
        self.Compact = channel.unary_unary(
                '/gqldb.AdminService/Compact',
                request_serializer=gqldb__pb2.CompactRequest.SerializeToString,
                response_deserializer=gqldb__pb2.CompactResponse.FromString,
                _registered_method=True)


class AdminServiceServicer(object):
    """=============================================================================
    Admin Service
    =============================================================================

    """

    def WarmupParser(self, request, context):
        """WarmupParser pre-allocates parser instances for better performance.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCacheStats(self, request, context):
        """GetCacheStats returns cache statistics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ClearCache(self, request, context):
        """ClearCache clears specified caches.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStatistics(self, request, context):
        """GetStatistics returns database statistics.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InvalidatePermissionCache(self, request, context):
        """InvalidatePermissionCache invalidates RBAC permission cache.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Compact(self, request, context):
        """Compact triggers manual compaction of the database storage.
        """
        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 = {
            'WarmupParser': grpc.unary_unary_rpc_method_handler(
                    servicer.WarmupParser,
                    request_deserializer=gqldb__pb2.WarmupParserRequest.FromString,
                    response_serializer=gqldb__pb2.WarmupParserResponse.SerializeToString,
            ),
            'GetCacheStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCacheStats,
                    request_deserializer=gqldb__pb2.GetCacheStatsRequest.FromString,
                    response_serializer=gqldb__pb2.CacheStatsResponse.SerializeToString,
            ),
            'ClearCache': grpc.unary_unary_rpc_method_handler(
                    servicer.ClearCache,
                    request_deserializer=gqldb__pb2.ClearCacheRequest.FromString,
                    response_serializer=gqldb__pb2.ClearCacheResponse.SerializeToString,
            ),
            'GetStatistics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStatistics,
                    request_deserializer=gqldb__pb2.GetStatisticsRequest.FromString,
                    response_serializer=gqldb__pb2.GetStatisticsResponse.SerializeToString,
            ),
            'InvalidatePermissionCache': grpc.unary_unary_rpc_method_handler(
                    servicer.InvalidatePermissionCache,
                    request_deserializer=gqldb__pb2.InvalidatePermissionCacheRequest.FromString,
                    response_serializer=gqldb__pb2.InvalidatePermissionCacheResponse.SerializeToString,
            ),
            'Compact': grpc.unary_unary_rpc_method_handler(
                    servicer.Compact,
                    request_deserializer=gqldb__pb2.CompactRequest.FromString,
                    response_serializer=gqldb__pb2.CompactResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.AdminService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.AdminService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class AdminService(object):
    """=============================================================================
    Admin Service
    =============================================================================

    """

    @staticmethod
    def WarmupParser(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,
            '/gqldb.AdminService/WarmupParser',
            gqldb__pb2.WarmupParserRequest.SerializeToString,
            gqldb__pb2.WarmupParserResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCacheStats(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,
            '/gqldb.AdminService/GetCacheStats',
            gqldb__pb2.GetCacheStatsRequest.SerializeToString,
            gqldb__pb2.CacheStatsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ClearCache(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,
            '/gqldb.AdminService/ClearCache',
            gqldb__pb2.ClearCacheRequest.SerializeToString,
            gqldb__pb2.ClearCacheResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStatistics(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,
            '/gqldb.AdminService/GetStatistics',
            gqldb__pb2.GetStatisticsRequest.SerializeToString,
            gqldb__pb2.GetStatisticsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InvalidatePermissionCache(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,
            '/gqldb.AdminService/InvalidatePermissionCache',
            gqldb__pb2.InvalidatePermissionCacheRequest.SerializeToString,
            gqldb__pb2.InvalidatePermissionCacheResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Compact(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,
            '/gqldb.AdminService/Compact',
            gqldb__pb2.CompactRequest.SerializeToString,
            gqldb__pb2.CompactResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class BulkImportServiceStub(object):
    """=============================================================================
    Bulk Import Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.StartBulkImport = channel.unary_unary(
                '/gqldb.BulkImportService/StartBulkImport',
                request_serializer=gqldb__pb2.StartBulkImportRequest.SerializeToString,
                response_deserializer=gqldb__pb2.StartBulkImportResponse.FromString,
                _registered_method=True)
        self.Checkpoint = channel.unary_unary(
                '/gqldb.BulkImportService/Checkpoint',
                request_serializer=gqldb__pb2.CheckpointRequest.SerializeToString,
                response_deserializer=gqldb__pb2.CheckpointResponse.FromString,
                _registered_method=True)
        self.EndBulkImport = channel.unary_unary(
                '/gqldb.BulkImportService/EndBulkImport',
                request_serializer=gqldb__pb2.EndBulkImportRequest.SerializeToString,
                response_deserializer=gqldb__pb2.EndBulkImportResponse.FromString,
                _registered_method=True)
        self.AbortBulkImport = channel.unary_unary(
                '/gqldb.BulkImportService/AbortBulkImport',
                request_serializer=gqldb__pb2.AbortBulkImportRequest.SerializeToString,
                response_deserializer=gqldb__pb2.AbortBulkImportResponse.FromString,
                _registered_method=True)
        self.GetBulkImportStatus = channel.unary_unary(
                '/gqldb.BulkImportService/GetBulkImportStatus',
                request_serializer=gqldb__pb2.GetBulkImportStatusRequest.SerializeToString,
                response_deserializer=gqldb__pb2.GetBulkImportStatusResponse.FromString,
                _registered_method=True)


class BulkImportServiceServicer(object):
    """=============================================================================
    Bulk Import Service
    =============================================================================

    """

    def StartBulkImport(self, request, context):
        """StartBulkImport starts a bulk import session for optimized high-throughput inserts.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Checkpoint(self, request, context):
        """Checkpoint flushes all accumulated data to disk for durability.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EndBulkImport(self, request, context):
        """EndBulkImport ends the session with a final checkpoint.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AbortBulkImport(self, request, context):
        """AbortBulkImport cancels the session without final sync.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetBulkImportStatus(self, request, context):
        """GetBulkImportStatus returns the current status of a bulk import session.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_BulkImportServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'StartBulkImport': grpc.unary_unary_rpc_method_handler(
                    servicer.StartBulkImport,
                    request_deserializer=gqldb__pb2.StartBulkImportRequest.FromString,
                    response_serializer=gqldb__pb2.StartBulkImportResponse.SerializeToString,
            ),
            'Checkpoint': grpc.unary_unary_rpc_method_handler(
                    servicer.Checkpoint,
                    request_deserializer=gqldb__pb2.CheckpointRequest.FromString,
                    response_serializer=gqldb__pb2.CheckpointResponse.SerializeToString,
            ),
            'EndBulkImport': grpc.unary_unary_rpc_method_handler(
                    servicer.EndBulkImport,
                    request_deserializer=gqldb__pb2.EndBulkImportRequest.FromString,
                    response_serializer=gqldb__pb2.EndBulkImportResponse.SerializeToString,
            ),
            'AbortBulkImport': grpc.unary_unary_rpc_method_handler(
                    servicer.AbortBulkImport,
                    request_deserializer=gqldb__pb2.AbortBulkImportRequest.FromString,
                    response_serializer=gqldb__pb2.AbortBulkImportResponse.SerializeToString,
            ),
            'GetBulkImportStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBulkImportStatus,
                    request_deserializer=gqldb__pb2.GetBulkImportStatusRequest.FromString,
                    response_serializer=gqldb__pb2.GetBulkImportStatusResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gqldb.BulkImportService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gqldb.BulkImportService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class BulkImportService(object):
    """=============================================================================
    Bulk Import Service
    =============================================================================

    """

    @staticmethod
    def StartBulkImport(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,
            '/gqldb.BulkImportService/StartBulkImport',
            gqldb__pb2.StartBulkImportRequest.SerializeToString,
            gqldb__pb2.StartBulkImportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Checkpoint(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,
            '/gqldb.BulkImportService/Checkpoint',
            gqldb__pb2.CheckpointRequest.SerializeToString,
            gqldb__pb2.CheckpointResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EndBulkImport(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,
            '/gqldb.BulkImportService/EndBulkImport',
            gqldb__pb2.EndBulkImportRequest.SerializeToString,
            gqldb__pb2.EndBulkImportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AbortBulkImport(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,
            '/gqldb.BulkImportService/AbortBulkImport',
            gqldb__pb2.AbortBulkImportRequest.SerializeToString,
            gqldb__pb2.AbortBulkImportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBulkImportStatus(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,
            '/gqldb.BulkImportService/GetBulkImportStatus',
            gqldb__pb2.GetBulkImportStatusRequest.SerializeToString,
            gqldb__pb2.GetBulkImportStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
