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

from . import coordinator_service_pb2 as coordinator__service__pb2


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,
        )
        self.TombstoneContent = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/TombstoneContent",
            request_serializer=coordinator__service__pb2.TombstoneContentRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.TombstoneContentResponse.FromString,
        )
        self.GetContentMetadata = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetContentMetadata",
            request_serializer=coordinator__service__pb2.GetContentMetadataRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetContentMetadataResponse.FromString,
        )
        self.GetContentTreeMetadata = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetContentTreeMetadata",
            request_serializer=coordinator__service__pb2.GetContentTreeMetadataRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetContentTreeMetadataResponse.FromString,
        )
        self.ListContent = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListContent",
            request_serializer=coordinator__service__pb2.ListContentRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListContentResponse.FromString,
        )
        self.CreateExtractionGraph = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/CreateExtractionGraph",
            request_serializer=coordinator__service__pb2.CreateExtractionGraphRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.CreateExtractionGraphResponse.FromString,
        )
        self.ListExtractionGraphs = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListExtractionGraphs",
            request_serializer=coordinator__service__pb2.ListExtractionGraphRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListExtractionGraphResponse.FromString,
        )
        self.CreateNS = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/CreateNS",
            request_serializer=coordinator__service__pb2.CreateNamespaceRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.CreateNamespaceResponse.FromString,
        )
        self.ListNS = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListNS",
            request_serializer=coordinator__service__pb2.ListNamespaceRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListNamespaceResponse.FromString,
        )
        self.GetNS = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetNS",
            request_serializer=coordinator__service__pb2.GetNamespaceRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetNamespaceResponse.FromString,
        )
        self.ListExtractors = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListExtractors",
            request_serializer=coordinator__service__pb2.ListExtractorsRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListExtractorsResponse.FromString,
        )
        self.RegisterExecutor = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/RegisterExecutor",
            request_serializer=coordinator__service__pb2.RegisterExecutorRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.RegisterExecutorResponse.FromString,
        )
        self.RegisterIngestionServer = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/RegisterIngestionServer",
            request_serializer=coordinator__service__pb2.RegisterIngestionServerRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.RegisterIngestionServerResponse.FromString,
        )
        self.RemoveIngestionServer = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/RemoveIngestionServer",
            request_serializer=coordinator__service__pb2.RemoveIngestionServerRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.RemoveIngestionServerResponse.FromString,
        )
        self.CreateGCTasks = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/CreateGCTasks",
            request_serializer=coordinator__service__pb2.CreateGCTasksRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.CreateGCTasksResponse.FromString,
        )
        self.GCTasksStream = channel.stream_stream(
            "/indexify_coordinator.CoordinatorService/GCTasksStream",
            request_serializer=coordinator__service__pb2.GCTaskAcknowledgement.SerializeToString,
            response_deserializer=coordinator__service__pb2.CoordinatorCommand.FromString,
        )
        self.Heartbeat = channel.stream_stream(
            "/indexify_coordinator.CoordinatorService/Heartbeat",
            request_serializer=coordinator__service__pb2.HeartbeatRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.HeartbeatResponse.FromString,
        )
        self.GetExtractionGraphAnalytics = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetExtractionGraphAnalytics",
            request_serializer=coordinator__service__pb2.GetExtractionGraphAnalyticsRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetExtractionGraphAnalyticsResponse.FromString,
        )
        self.ListIndexes = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListIndexes",
            request_serializer=coordinator__service__pb2.ListIndexesRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListIndexesResponse.FromString,
        )
        self.GetIndex = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetIndex",
            request_serializer=coordinator__service__pb2.GetIndexRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetIndexResponse.FromString,
        )
        self.UpdateIndexesState = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/UpdateIndexesState",
            request_serializer=coordinator__service__pb2.UpdateIndexesStateRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.UpdateIndexesStateResponse.FromString,
        )
        self.GetExtractorCoordinates = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetExtractorCoordinates",
            request_serializer=coordinator__service__pb2.GetExtractorCoordinatesRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetExtractorCoordinatesResponse.FromString,
        )
        self.UpdateTask = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/UpdateTask",
            request_serializer=coordinator__service__pb2.UpdateTaskRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.UpdateTaskResponse.FromString,
        )
        self.ListStateChanges = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListStateChanges",
            request_serializer=coordinator__service__pb2.ListStateChangesRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListStateChangesResponse.FromString,
        )
        self.ListTasks = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListTasks",
            request_serializer=coordinator__service__pb2.ListTasksRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListTasksResponse.FromString,
        )
        self.GetSchema = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetSchema",
            request_serializer=coordinator__service__pb2.GetSchemaRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetSchemaResponse.FromString,
        )
        self.ListSchemas = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListSchemas",
            request_serializer=coordinator__service__pb2.GetAllSchemaRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetAllSchemaResponse.FromString,
        )
        self.GetRaftMetricsSnapshot = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetRaftMetricsSnapshot",
            request_serializer=coordinator__service__pb2.GetRaftMetricsSnapshotRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.RaftMetricsSnapshotResponse.FromString,
        )
        self.GetAllTaskAssignments = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetAllTaskAssignments",
            request_serializer=coordinator__service__pb2.GetAllTaskAssignmentRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.TaskAssignments.FromString,
        )
        self.GetTask = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetTask",
            request_serializer=coordinator__service__pb2.GetTaskRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetTaskResponse.FromString,
        )
        self.GetIngestionInfo = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/GetIngestionInfo",
            request_serializer=coordinator__service__pb2.GetIngestionInfoRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.GetIngestionInfoResponse.FromString,
        )
        self.WaitContentExtraction = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/WaitContentExtraction",
            request_serializer=coordinator__service__pb2.WaitContentExtractionRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.WaitContentExtractionResponse.FromString,
        )
        self.ListActiveContents = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ListActiveContents",
            request_serializer=coordinator__service__pb2.ListActiveContentsRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ListActiveContentsResponse.FromString,
        )
        self.UpdateLabels = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/UpdateLabels",
            request_serializer=coordinator__service__pb2.UpdateLabelsRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.UpdateLabelsResponse.FromString,
        )
        self.ExecutorsHeartbeat = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ExecutorsHeartbeat",
            request_serializer=coordinator__service__pb2.ExecutorsHeartbeatRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ExecutorsHeartbeatResponse.FromString,
        )
        self.LinkExtractionGraphs = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/LinkExtractionGraphs",
            request_serializer=coordinator__service__pb2.LinkExtractionGraphsRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.LinkExtractionGraphsResponse.FromString,
        )
        self.ExtractionGraphLinks = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/ExtractionGraphLinks",
            request_serializer=coordinator__service__pb2.ExtractionGraphLinksRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ExtractionGraphLinksResponse.FromString,
        )
        self.AddGraphToContent = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/AddGraphToContent",
            request_serializer=coordinator__service__pb2.AddGraphToContentRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.AddGraphToContentResponse.FromString,
        )
        self.ContentStream = channel.unary_stream(
            "/indexify_coordinator.CoordinatorService/ContentStream",
            request_serializer=coordinator__service__pb2.ContentStreamRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.ContentStreamItem.FromString,
        )
        self.DeleteExtractionGraph = channel.unary_unary(
            "/indexify_coordinator.CoordinatorService/DeleteExtractionGraph",
            request_serializer=coordinator__service__pb2.DeleteExtractionGraphRequest.SerializeToString,
            response_deserializer=coordinator__service__pb2.Empty.FromString,
        )


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 ListExtractionGraphs(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 GetExtractionGraphAnalytics(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 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 WaitContentExtraction(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 ListActiveContents(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 UpdateLabels(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 ExecutorsHeartbeat(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 LinkExtractionGraphs(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 ExtractionGraphLinks(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 AddGraphToContent(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 ContentStream(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 DeleteExtractionGraph(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,
        ),
        "ListExtractionGraphs": grpc.unary_unary_rpc_method_handler(
            servicer.ListExtractionGraphs,
            request_deserializer=coordinator__service__pb2.ListExtractionGraphRequest.FromString,
            response_serializer=coordinator__service__pb2.ListExtractionGraphResponse.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,
        ),
        "GetExtractionGraphAnalytics": grpc.unary_unary_rpc_method_handler(
            servicer.GetExtractionGraphAnalytics,
            request_deserializer=coordinator__service__pb2.GetExtractionGraphAnalyticsRequest.FromString,
            response_serializer=coordinator__service__pb2.GetExtractionGraphAnalyticsResponse.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,
        ),
        "WaitContentExtraction": grpc.unary_unary_rpc_method_handler(
            servicer.WaitContentExtraction,
            request_deserializer=coordinator__service__pb2.WaitContentExtractionRequest.FromString,
            response_serializer=coordinator__service__pb2.WaitContentExtractionResponse.SerializeToString,
        ),
        "ListActiveContents": grpc.unary_unary_rpc_method_handler(
            servicer.ListActiveContents,
            request_deserializer=coordinator__service__pb2.ListActiveContentsRequest.FromString,
            response_serializer=coordinator__service__pb2.ListActiveContentsResponse.SerializeToString,
        ),
        "UpdateLabels": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateLabels,
            request_deserializer=coordinator__service__pb2.UpdateLabelsRequest.FromString,
            response_serializer=coordinator__service__pb2.UpdateLabelsResponse.SerializeToString,
        ),
        "ExecutorsHeartbeat": grpc.unary_unary_rpc_method_handler(
            servicer.ExecutorsHeartbeat,
            request_deserializer=coordinator__service__pb2.ExecutorsHeartbeatRequest.FromString,
            response_serializer=coordinator__service__pb2.ExecutorsHeartbeatResponse.SerializeToString,
        ),
        "LinkExtractionGraphs": grpc.unary_unary_rpc_method_handler(
            servicer.LinkExtractionGraphs,
            request_deserializer=coordinator__service__pb2.LinkExtractionGraphsRequest.FromString,
            response_serializer=coordinator__service__pb2.LinkExtractionGraphsResponse.SerializeToString,
        ),
        "ExtractionGraphLinks": grpc.unary_unary_rpc_method_handler(
            servicer.ExtractionGraphLinks,
            request_deserializer=coordinator__service__pb2.ExtractionGraphLinksRequest.FromString,
            response_serializer=coordinator__service__pb2.ExtractionGraphLinksResponse.SerializeToString,
        ),
        "AddGraphToContent": grpc.unary_unary_rpc_method_handler(
            servicer.AddGraphToContent,
            request_deserializer=coordinator__service__pb2.AddGraphToContentRequest.FromString,
            response_serializer=coordinator__service__pb2.AddGraphToContentResponse.SerializeToString,
        ),
        "ContentStream": grpc.unary_stream_rpc_method_handler(
            servicer.ContentStream,
            request_deserializer=coordinator__service__pb2.ContentStreamRequest.FromString,
            response_serializer=coordinator__service__pb2.ContentStreamItem.SerializeToString,
        ),
        "DeleteExtractionGraph": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteExtractionGraph,
            request_deserializer=coordinator__service__pb2.DeleteExtractionGraphRequest.FromString,
            response_serializer=coordinator__service__pb2.Empty.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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @staticmethod
    def ListExtractionGraphs(
        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/ListExtractionGraphs",
            coordinator__service__pb2.ListExtractionGraphRequest.SerializeToString,
            coordinator__service__pb2.ListExtractionGraphResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @staticmethod
    def GetExtractionGraphAnalytics(
        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/GetExtractionGraphAnalytics",
            coordinator__service__pb2.GetExtractionGraphAnalyticsRequest.SerializeToString,
            coordinator__service__pb2.GetExtractionGraphAnalyticsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @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,
        )

    @staticmethod
    def WaitContentExtraction(
        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/WaitContentExtraction",
            coordinator__service__pb2.WaitContentExtractionRequest.SerializeToString,
            coordinator__service__pb2.WaitContentExtractionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListActiveContents(
        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/ListActiveContents",
            coordinator__service__pb2.ListActiveContentsRequest.SerializeToString,
            coordinator__service__pb2.ListActiveContentsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateLabels(
        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/UpdateLabels",
            coordinator__service__pb2.UpdateLabelsRequest.SerializeToString,
            coordinator__service__pb2.UpdateLabelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ExecutorsHeartbeat(
        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/ExecutorsHeartbeat",
            coordinator__service__pb2.ExecutorsHeartbeatRequest.SerializeToString,
            coordinator__service__pb2.ExecutorsHeartbeatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def LinkExtractionGraphs(
        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/LinkExtractionGraphs",
            coordinator__service__pb2.LinkExtractionGraphsRequest.SerializeToString,
            coordinator__service__pb2.LinkExtractionGraphsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ExtractionGraphLinks(
        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/ExtractionGraphLinks",
            coordinator__service__pb2.ExtractionGraphLinksRequest.SerializeToString,
            coordinator__service__pb2.ExtractionGraphLinksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def AddGraphToContent(
        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/AddGraphToContent",
            coordinator__service__pb2.AddGraphToContentRequest.SerializeToString,
            coordinator__service__pb2.AddGraphToContentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ContentStream(
        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,
            "/indexify_coordinator.CoordinatorService/ContentStream",
            coordinator__service__pb2.ContentStreamRequest.SerializeToString,
            coordinator__service__pb2.ContentStreamItem.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeleteExtractionGraph(
        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/DeleteExtractionGraph",
            coordinator__service__pb2.DeleteExtractionGraphRequest.SerializeToString,
            coordinator__service__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )
