# 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 coordinator_service_pb2 as coordinator__service__pb2

GRPC_GENERATED_VERSION = '1.63.0'
GRPC_VERSION = grpc.__version__
EXPECTED_ERROR_RELEASE = '1.65.0'
SCHEDULED_RELEASE_DATE = 'June 25, 2024'
_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:
    warnings.warn(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in coordinator_service_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}.'
        + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},'
        + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.',
        RuntimeWarning
    )


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateContent = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/CreateContent',
                request_serializer=coordinator__service__pb2.CreateContentRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.CreateContentResponse.FromString,
                _registered_method=True)
        self.TombstoneContent = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/TombstoneContent',
                request_serializer=coordinator__service__pb2.TombstoneContentRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.TombstoneContentResponse.FromString,
                _registered_method=True)
        self.GetContentMetadata = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetContentMetadata',
                request_serializer=coordinator__service__pb2.GetContentMetadataRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetContentMetadataResponse.FromString,
                _registered_method=True)
        self.GetContentTreeMetadata = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetContentTreeMetadata',
                request_serializer=coordinator__service__pb2.GetContentTreeMetadataRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetContentTreeMetadataResponse.FromString,
                _registered_method=True)
        self.ListContent = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListContent',
                request_serializer=coordinator__service__pb2.ListContentRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListContentResponse.FromString,
                _registered_method=True)
        self.CreateExtractionGraph = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/CreateExtractionGraph',
                request_serializer=coordinator__service__pb2.CreateExtractionGraphRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.CreateExtractionGraphResponse.FromString,
                _registered_method=True)
        self.GetExtractionPolicy = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetExtractionPolicy',
                request_serializer=coordinator__service__pb2.GetExtractionPolicyRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetExtractionPolicyResponse.FromString,
                _registered_method=True)
        self.ListExtractionPolicies = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListExtractionPolicies',
                request_serializer=coordinator__service__pb2.ListExtractionPoliciesRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListExtractionPoliciesResponse.FromString,
                _registered_method=True)
        self.CreateNS = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/CreateNS',
                request_serializer=coordinator__service__pb2.CreateNamespaceRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.CreateNamespaceResponse.FromString,
                _registered_method=True)
        self.ListNS = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListNS',
                request_serializer=coordinator__service__pb2.ListNamespaceRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListNamespaceResponse.FromString,
                _registered_method=True)
        self.GetNS = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetNS',
                request_serializer=coordinator__service__pb2.GetNamespaceRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetNamespaceResponse.FromString,
                _registered_method=True)
        self.ListExtractors = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListExtractors',
                request_serializer=coordinator__service__pb2.ListExtractorsRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListExtractorsResponse.FromString,
                _registered_method=True)
        self.RegisterExecutor = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/RegisterExecutor',
                request_serializer=coordinator__service__pb2.RegisterExecutorRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.RegisterExecutorResponse.FromString,
                _registered_method=True)
        self.RegisterIngestionServer = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/RegisterIngestionServer',
                request_serializer=coordinator__service__pb2.RegisterIngestionServerRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.RegisterIngestionServerResponse.FromString,
                _registered_method=True)
        self.RemoveIngestionServer = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/RemoveIngestionServer',
                request_serializer=coordinator__service__pb2.RemoveIngestionServerRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.RemoveIngestionServerResponse.FromString,
                _registered_method=True)
        self.CreateGCTasks = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/CreateGCTasks',
                request_serializer=coordinator__service__pb2.CreateGCTasksRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.CreateGCTasksResponse.FromString,
                _registered_method=True)
        self.GCTasksStream = channel.stream_stream(
                '/indexify_coordinator.CoordinatorService/GCTasksStream',
                request_serializer=coordinator__service__pb2.GCTaskAcknowledgement.SerializeToString,
                response_deserializer=coordinator__service__pb2.CoordinatorCommand.FromString,
                _registered_method=True)
        self.Heartbeat = channel.stream_stream(
                '/indexify_coordinator.CoordinatorService/Heartbeat',
                request_serializer=coordinator__service__pb2.HeartbeatRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.HeartbeatResponse.FromString,
                _registered_method=True)
        self.ListIndexes = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListIndexes',
                request_serializer=coordinator__service__pb2.ListIndexesRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListIndexesResponse.FromString,
                _registered_method=True)
        self.GetIndex = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetIndex',
                request_serializer=coordinator__service__pb2.GetIndexRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetIndexResponse.FromString,
                _registered_method=True)
        self.UpdateIndexesState = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/UpdateIndexesState',
                request_serializer=coordinator__service__pb2.UpdateIndexesStateRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.UpdateIndexesStateResponse.FromString,
                _registered_method=True)
        self.GetExtractorCoordinates = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetExtractorCoordinates',
                request_serializer=coordinator__service__pb2.GetExtractorCoordinatesRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetExtractorCoordinatesResponse.FromString,
                _registered_method=True)
        self.UpdateTask = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/UpdateTask',
                request_serializer=coordinator__service__pb2.UpdateTaskRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.UpdateTaskResponse.FromString,
                _registered_method=True)
        self.ListStateChanges = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListStateChanges',
                request_serializer=coordinator__service__pb2.ListStateChangesRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListStateChangesResponse.FromString,
                _registered_method=True)
        self.ListTasks = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListTasks',
                request_serializer=coordinator__service__pb2.ListTasksRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.ListTasksResponse.FromString,
                _registered_method=True)
        self.GetSchema = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetSchema',
                request_serializer=coordinator__service__pb2.GetSchemaRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetSchemaResponse.FromString,
                _registered_method=True)
        self.ListSchemas = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/ListSchemas',
                request_serializer=coordinator__service__pb2.GetAllSchemaRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetAllSchemaResponse.FromString,
                _registered_method=True)
        self.GetRaftMetricsSnapshot = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetRaftMetricsSnapshot',
                request_serializer=coordinator__service__pb2.GetRaftMetricsSnapshotRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.RaftMetricsSnapshotResponse.FromString,
                _registered_method=True)
        self.GetAllTaskAssignments = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetAllTaskAssignments',
                request_serializer=coordinator__service__pb2.GetAllTaskAssignmentRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.TaskAssignments.FromString,
                _registered_method=True)
        self.GetTask = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetTask',
                request_serializer=coordinator__service__pb2.GetTaskRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetTaskResponse.FromString,
                _registered_method=True)
        self.GetIngestionInfo = channel.unary_unary(
                '/indexify_coordinator.CoordinatorService/GetIngestionInfo',
                request_serializer=coordinator__service__pb2.GetIngestionInfoRequest.SerializeToString,
                response_deserializer=coordinator__service__pb2.GetIngestionInfoResponse.FromString,
                _registered_method=True)


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

    def CreateContent(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 TombstoneContent(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 GetContentMetadata(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 GetContentTreeMetadata(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 ListContent(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 CreateExtractionGraph(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 GetExtractionPolicy(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 ListExtractionPolicies(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 CreateNS(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 ListNS(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 GetNS(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 ListExtractors(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 RegisterExecutor(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 RegisterIngestionServer(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 RemoveIngestionServer(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 CreateGCTasks(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 GCTasksStream(self, request_iterator, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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

    def ListIndexes(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 GetIndex(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 UpdateIndexesState(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 GetExtractorCoordinates(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 UpdateTask(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 ListStateChanges(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 ListTasks(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 GetSchema(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 ListSchemas(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 GetRaftMetricsSnapshot(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 GetAllTaskAssignments(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 GetTask(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 GetIngestionInfo(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_CoordinatorServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateContent': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateContent,
                    request_deserializer=coordinator__service__pb2.CreateContentRequest.FromString,
                    response_serializer=coordinator__service__pb2.CreateContentResponse.SerializeToString,
            ),
            'TombstoneContent': grpc.unary_unary_rpc_method_handler(
                    servicer.TombstoneContent,
                    request_deserializer=coordinator__service__pb2.TombstoneContentRequest.FromString,
                    response_serializer=coordinator__service__pb2.TombstoneContentResponse.SerializeToString,
            ),
            'GetContentMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.GetContentMetadata,
                    request_deserializer=coordinator__service__pb2.GetContentMetadataRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetContentMetadataResponse.SerializeToString,
            ),
            'GetContentTreeMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.GetContentTreeMetadata,
                    request_deserializer=coordinator__service__pb2.GetContentTreeMetadataRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetContentTreeMetadataResponse.SerializeToString,
            ),
            'ListContent': grpc.unary_unary_rpc_method_handler(
                    servicer.ListContent,
                    request_deserializer=coordinator__service__pb2.ListContentRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListContentResponse.SerializeToString,
            ),
            'CreateExtractionGraph': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateExtractionGraph,
                    request_deserializer=coordinator__service__pb2.CreateExtractionGraphRequest.FromString,
                    response_serializer=coordinator__service__pb2.CreateExtractionGraphResponse.SerializeToString,
            ),
            'GetExtractionPolicy': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExtractionPolicy,
                    request_deserializer=coordinator__service__pb2.GetExtractionPolicyRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetExtractionPolicyResponse.SerializeToString,
            ),
            'ListExtractionPolicies': grpc.unary_unary_rpc_method_handler(
                    servicer.ListExtractionPolicies,
                    request_deserializer=coordinator__service__pb2.ListExtractionPoliciesRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListExtractionPoliciesResponse.SerializeToString,
            ),
            'CreateNS': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateNS,
                    request_deserializer=coordinator__service__pb2.CreateNamespaceRequest.FromString,
                    response_serializer=coordinator__service__pb2.CreateNamespaceResponse.SerializeToString,
            ),
            'ListNS': grpc.unary_unary_rpc_method_handler(
                    servicer.ListNS,
                    request_deserializer=coordinator__service__pb2.ListNamespaceRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListNamespaceResponse.SerializeToString,
            ),
            'GetNS': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNS,
                    request_deserializer=coordinator__service__pb2.GetNamespaceRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetNamespaceResponse.SerializeToString,
            ),
            'ListExtractors': grpc.unary_unary_rpc_method_handler(
                    servicer.ListExtractors,
                    request_deserializer=coordinator__service__pb2.ListExtractorsRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListExtractorsResponse.SerializeToString,
            ),
            'RegisterExecutor': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterExecutor,
                    request_deserializer=coordinator__service__pb2.RegisterExecutorRequest.FromString,
                    response_serializer=coordinator__service__pb2.RegisterExecutorResponse.SerializeToString,
            ),
            'RegisterIngestionServer': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterIngestionServer,
                    request_deserializer=coordinator__service__pb2.RegisterIngestionServerRequest.FromString,
                    response_serializer=coordinator__service__pb2.RegisterIngestionServerResponse.SerializeToString,
            ),
            'RemoveIngestionServer': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveIngestionServer,
                    request_deserializer=coordinator__service__pb2.RemoveIngestionServerRequest.FromString,
                    response_serializer=coordinator__service__pb2.RemoveIngestionServerResponse.SerializeToString,
            ),
            'CreateGCTasks': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateGCTasks,
                    request_deserializer=coordinator__service__pb2.CreateGCTasksRequest.FromString,
                    response_serializer=coordinator__service__pb2.CreateGCTasksResponse.SerializeToString,
            ),
            'GCTasksStream': grpc.stream_stream_rpc_method_handler(
                    servicer.GCTasksStream,
                    request_deserializer=coordinator__service__pb2.GCTaskAcknowledgement.FromString,
                    response_serializer=coordinator__service__pb2.CoordinatorCommand.SerializeToString,
            ),
            'Heartbeat': grpc.stream_stream_rpc_method_handler(
                    servicer.Heartbeat,
                    request_deserializer=coordinator__service__pb2.HeartbeatRequest.FromString,
                    response_serializer=coordinator__service__pb2.HeartbeatResponse.SerializeToString,
            ),
            'ListIndexes': grpc.unary_unary_rpc_method_handler(
                    servicer.ListIndexes,
                    request_deserializer=coordinator__service__pb2.ListIndexesRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListIndexesResponse.SerializeToString,
            ),
            'GetIndex': grpc.unary_unary_rpc_method_handler(
                    servicer.GetIndex,
                    request_deserializer=coordinator__service__pb2.GetIndexRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetIndexResponse.SerializeToString,
            ),
            'UpdateIndexesState': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateIndexesState,
                    request_deserializer=coordinator__service__pb2.UpdateIndexesStateRequest.FromString,
                    response_serializer=coordinator__service__pb2.UpdateIndexesStateResponse.SerializeToString,
            ),
            'GetExtractorCoordinates': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExtractorCoordinates,
                    request_deserializer=coordinator__service__pb2.GetExtractorCoordinatesRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetExtractorCoordinatesResponse.SerializeToString,
            ),
            'UpdateTask': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateTask,
                    request_deserializer=coordinator__service__pb2.UpdateTaskRequest.FromString,
                    response_serializer=coordinator__service__pb2.UpdateTaskResponse.SerializeToString,
            ),
            'ListStateChanges': grpc.unary_unary_rpc_method_handler(
                    servicer.ListStateChanges,
                    request_deserializer=coordinator__service__pb2.ListStateChangesRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListStateChangesResponse.SerializeToString,
            ),
            'ListTasks': grpc.unary_unary_rpc_method_handler(
                    servicer.ListTasks,
                    request_deserializer=coordinator__service__pb2.ListTasksRequest.FromString,
                    response_serializer=coordinator__service__pb2.ListTasksResponse.SerializeToString,
            ),
            'GetSchema': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSchema,
                    request_deserializer=coordinator__service__pb2.GetSchemaRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetSchemaResponse.SerializeToString,
            ),
            'ListSchemas': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSchemas,
                    request_deserializer=coordinator__service__pb2.GetAllSchemaRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetAllSchemaResponse.SerializeToString,
            ),
            'GetRaftMetricsSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRaftMetricsSnapshot,
                    request_deserializer=coordinator__service__pb2.GetRaftMetricsSnapshotRequest.FromString,
                    response_serializer=coordinator__service__pb2.RaftMetricsSnapshotResponse.SerializeToString,
            ),
            'GetAllTaskAssignments': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAllTaskAssignments,
                    request_deserializer=coordinator__service__pb2.GetAllTaskAssignmentRequest.FromString,
                    response_serializer=coordinator__service__pb2.TaskAssignments.SerializeToString,
            ),
            'GetTask': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTask,
                    request_deserializer=coordinator__service__pb2.GetTaskRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetTaskResponse.SerializeToString,
            ),
            'GetIngestionInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetIngestionInfo,
                    request_deserializer=coordinator__service__pb2.GetIngestionInfoRequest.FromString,
                    response_serializer=coordinator__service__pb2.GetIngestionInfoResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'indexify_coordinator.CoordinatorService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def CreateContent(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,
            '/indexify_coordinator.CoordinatorService/CreateContent',
            coordinator__service__pb2.CreateContentRequest.SerializeToString,
            coordinator__service__pb2.CreateContentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TombstoneContent(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,
            '/indexify_coordinator.CoordinatorService/TombstoneContent',
            coordinator__service__pb2.TombstoneContentRequest.SerializeToString,
            coordinator__service__pb2.TombstoneContentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetContentMetadata(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,
            '/indexify_coordinator.CoordinatorService/GetContentMetadata',
            coordinator__service__pb2.GetContentMetadataRequest.SerializeToString,
            coordinator__service__pb2.GetContentMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetContentTreeMetadata(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,
            '/indexify_coordinator.CoordinatorService/GetContentTreeMetadata',
            coordinator__service__pb2.GetContentTreeMetadataRequest.SerializeToString,
            coordinator__service__pb2.GetContentTreeMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListContent(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,
            '/indexify_coordinator.CoordinatorService/ListContent',
            coordinator__service__pb2.ListContentRequest.SerializeToString,
            coordinator__service__pb2.ListContentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateExtractionGraph(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,
            '/indexify_coordinator.CoordinatorService/CreateExtractionGraph',
            coordinator__service__pb2.CreateExtractionGraphRequest.SerializeToString,
            coordinator__service__pb2.CreateExtractionGraphResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetExtractionPolicy(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,
            '/indexify_coordinator.CoordinatorService/GetExtractionPolicy',
            coordinator__service__pb2.GetExtractionPolicyRequest.SerializeToString,
            coordinator__service__pb2.GetExtractionPolicyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListExtractionPolicies(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,
            '/indexify_coordinator.CoordinatorService/ListExtractionPolicies',
            coordinator__service__pb2.ListExtractionPoliciesRequest.SerializeToString,
            coordinator__service__pb2.ListExtractionPoliciesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateNS(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,
            '/indexify_coordinator.CoordinatorService/CreateNS',
            coordinator__service__pb2.CreateNamespaceRequest.SerializeToString,
            coordinator__service__pb2.CreateNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListNS(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,
            '/indexify_coordinator.CoordinatorService/ListNS',
            coordinator__service__pb2.ListNamespaceRequest.SerializeToString,
            coordinator__service__pb2.ListNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetNS(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,
            '/indexify_coordinator.CoordinatorService/GetNS',
            coordinator__service__pb2.GetNamespaceRequest.SerializeToString,
            coordinator__service__pb2.GetNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListExtractors(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,
            '/indexify_coordinator.CoordinatorService/ListExtractors',
            coordinator__service__pb2.ListExtractorsRequest.SerializeToString,
            coordinator__service__pb2.ListExtractorsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterExecutor(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,
            '/indexify_coordinator.CoordinatorService/RegisterExecutor',
            coordinator__service__pb2.RegisterExecutorRequest.SerializeToString,
            coordinator__service__pb2.RegisterExecutorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterIngestionServer(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,
            '/indexify_coordinator.CoordinatorService/RegisterIngestionServer',
            coordinator__service__pb2.RegisterIngestionServerRequest.SerializeToString,
            coordinator__service__pb2.RegisterIngestionServerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveIngestionServer(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,
            '/indexify_coordinator.CoordinatorService/RemoveIngestionServer',
            coordinator__service__pb2.RemoveIngestionServerRequest.SerializeToString,
            coordinator__service__pb2.RemoveIngestionServerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateGCTasks(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,
            '/indexify_coordinator.CoordinatorService/CreateGCTasks',
            coordinator__service__pb2.CreateGCTasksRequest.SerializeToString,
            coordinator__service__pb2.CreateGCTasksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GCTasksStream(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/indexify_coordinator.CoordinatorService/GCTasksStream',
            coordinator__service__pb2.GCTaskAcknowledgement.SerializeToString,
            coordinator__service__pb2.CoordinatorCommand.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Heartbeat(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/indexify_coordinator.CoordinatorService/Heartbeat',
            coordinator__service__pb2.HeartbeatRequest.SerializeToString,
            coordinator__service__pb2.HeartbeatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListIndexes(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,
            '/indexify_coordinator.CoordinatorService/ListIndexes',
            coordinator__service__pb2.ListIndexesRequest.SerializeToString,
            coordinator__service__pb2.ListIndexesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetIndex(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,
            '/indexify_coordinator.CoordinatorService/GetIndex',
            coordinator__service__pb2.GetIndexRequest.SerializeToString,
            coordinator__service__pb2.GetIndexResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateIndexesState(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,
            '/indexify_coordinator.CoordinatorService/UpdateIndexesState',
            coordinator__service__pb2.UpdateIndexesStateRequest.SerializeToString,
            coordinator__service__pb2.UpdateIndexesStateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetExtractorCoordinates(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,
            '/indexify_coordinator.CoordinatorService/GetExtractorCoordinates',
            coordinator__service__pb2.GetExtractorCoordinatesRequest.SerializeToString,
            coordinator__service__pb2.GetExtractorCoordinatesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateTask(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,
            '/indexify_coordinator.CoordinatorService/UpdateTask',
            coordinator__service__pb2.UpdateTaskRequest.SerializeToString,
            coordinator__service__pb2.UpdateTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListStateChanges(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,
            '/indexify_coordinator.CoordinatorService/ListStateChanges',
            coordinator__service__pb2.ListStateChangesRequest.SerializeToString,
            coordinator__service__pb2.ListStateChangesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListTasks(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,
            '/indexify_coordinator.CoordinatorService/ListTasks',
            coordinator__service__pb2.ListTasksRequest.SerializeToString,
            coordinator__service__pb2.ListTasksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSchema(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,
            '/indexify_coordinator.CoordinatorService/GetSchema',
            coordinator__service__pb2.GetSchemaRequest.SerializeToString,
            coordinator__service__pb2.GetSchemaResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSchemas(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,
            '/indexify_coordinator.CoordinatorService/ListSchemas',
            coordinator__service__pb2.GetAllSchemaRequest.SerializeToString,
            coordinator__service__pb2.GetAllSchemaResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRaftMetricsSnapshot(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,
            '/indexify_coordinator.CoordinatorService/GetRaftMetricsSnapshot',
            coordinator__service__pb2.GetRaftMetricsSnapshotRequest.SerializeToString,
            coordinator__service__pb2.RaftMetricsSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAllTaskAssignments(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,
            '/indexify_coordinator.CoordinatorService/GetAllTaskAssignments',
            coordinator__service__pb2.GetAllTaskAssignmentRequest.SerializeToString,
            coordinator__service__pb2.TaskAssignments.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTask(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,
            '/indexify_coordinator.CoordinatorService/GetTask',
            coordinator__service__pb2.GetTaskRequest.SerializeToString,
            coordinator__service__pb2.GetTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetIngestionInfo(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,
            '/indexify_coordinator.CoordinatorService/GetIngestionInfo',
            coordinator__service__pb2.GetIngestionInfoRequest.SerializeToString,
            coordinator__service__pb2.GetIngestionInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
