cpu-diffusers.upgrade-tmp/backend_pb2_grpc.py

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

import backend_pb2 as backend__pb2

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

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

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


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Health = channel.unary_unary(
                '/backend.Backend/Health',
                request_serializer=backend__pb2.HealthMessage.SerializeToString,
                response_deserializer=backend__pb2.Reply.FromString,
                _registered_method=True)
        self.Free = channel.unary_unary(
                '/backend.Backend/Free',
                request_serializer=backend__pb2.HealthMessage.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.Predict = channel.unary_unary(
                '/backend.Backend/Predict',
                request_serializer=backend__pb2.PredictOptions.SerializeToString,
                response_deserializer=backend__pb2.Reply.FromString,
                _registered_method=True)
        self.LoadModel = channel.unary_unary(
                '/backend.Backend/LoadModel',
                request_serializer=backend__pb2.ModelOptions.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.PredictStream = channel.unary_stream(
                '/backend.Backend/PredictStream',
                request_serializer=backend__pb2.PredictOptions.SerializeToString,
                response_deserializer=backend__pb2.Reply.FromString,
                _registered_method=True)
        self.Embedding = channel.unary_unary(
                '/backend.Backend/Embedding',
                request_serializer=backend__pb2.PredictOptions.SerializeToString,
                response_deserializer=backend__pb2.EmbeddingResult.FromString,
                _registered_method=True)
        self.GenerateImage = channel.unary_unary(
                '/backend.Backend/GenerateImage',
                request_serializer=backend__pb2.GenerateImageRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.GenerateVideo = channel.unary_unary(
                '/backend.Backend/GenerateVideo',
                request_serializer=backend__pb2.GenerateVideoRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.AudioTranscription = channel.unary_unary(
                '/backend.Backend/AudioTranscription',
                request_serializer=backend__pb2.TranscriptRequest.SerializeToString,
                response_deserializer=backend__pb2.TranscriptResult.FromString,
                _registered_method=True)
        self.AudioTranscriptionStream = channel.unary_stream(
                '/backend.Backend/AudioTranscriptionStream',
                request_serializer=backend__pb2.TranscriptRequest.SerializeToString,
                response_deserializer=backend__pb2.TranscriptStreamResponse.FromString,
                _registered_method=True)
        self.TTS = channel.unary_unary(
                '/backend.Backend/TTS',
                request_serializer=backend__pb2.TTSRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.TTSStream = channel.unary_stream(
                '/backend.Backend/TTSStream',
                request_serializer=backend__pb2.TTSRequest.SerializeToString,
                response_deserializer=backend__pb2.Reply.FromString,
                _registered_method=True)
        self.SoundGeneration = channel.unary_unary(
                '/backend.Backend/SoundGeneration',
                request_serializer=backend__pb2.SoundGenerationRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.TokenizeString = channel.unary_unary(
                '/backend.Backend/TokenizeString',
                request_serializer=backend__pb2.PredictOptions.SerializeToString,
                response_deserializer=backend__pb2.TokenizationResponse.FromString,
                _registered_method=True)
        self.Status = channel.unary_unary(
                '/backend.Backend/Status',
                request_serializer=backend__pb2.HealthMessage.SerializeToString,
                response_deserializer=backend__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.Detect = channel.unary_unary(
                '/backend.Backend/Detect',
                request_serializer=backend__pb2.DetectOptions.SerializeToString,
                response_deserializer=backend__pb2.DetectResponse.FromString,
                _registered_method=True)
        self.FaceVerify = channel.unary_unary(
                '/backend.Backend/FaceVerify',
                request_serializer=backend__pb2.FaceVerifyRequest.SerializeToString,
                response_deserializer=backend__pb2.FaceVerifyResponse.FromString,
                _registered_method=True)
        self.FaceAnalyze = channel.unary_unary(
                '/backend.Backend/FaceAnalyze',
                request_serializer=backend__pb2.FaceAnalyzeRequest.SerializeToString,
                response_deserializer=backend__pb2.FaceAnalyzeResponse.FromString,
                _registered_method=True)
        self.VoiceVerify = channel.unary_unary(
                '/backend.Backend/VoiceVerify',
                request_serializer=backend__pb2.VoiceVerifyRequest.SerializeToString,
                response_deserializer=backend__pb2.VoiceVerifyResponse.FromString,
                _registered_method=True)
        self.VoiceAnalyze = channel.unary_unary(
                '/backend.Backend/VoiceAnalyze',
                request_serializer=backend__pb2.VoiceAnalyzeRequest.SerializeToString,
                response_deserializer=backend__pb2.VoiceAnalyzeResponse.FromString,
                _registered_method=True)
        self.VoiceEmbed = channel.unary_unary(
                '/backend.Backend/VoiceEmbed',
                request_serializer=backend__pb2.VoiceEmbedRequest.SerializeToString,
                response_deserializer=backend__pb2.VoiceEmbedResponse.FromString,
                _registered_method=True)
        self.StoresSet = channel.unary_unary(
                '/backend.Backend/StoresSet',
                request_serializer=backend__pb2.StoresSetOptions.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.StoresDelete = channel.unary_unary(
                '/backend.Backend/StoresDelete',
                request_serializer=backend__pb2.StoresDeleteOptions.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.StoresGet = channel.unary_unary(
                '/backend.Backend/StoresGet',
                request_serializer=backend__pb2.StoresGetOptions.SerializeToString,
                response_deserializer=backend__pb2.StoresGetResult.FromString,
                _registered_method=True)
        self.StoresFind = channel.unary_unary(
                '/backend.Backend/StoresFind',
                request_serializer=backend__pb2.StoresFindOptions.SerializeToString,
                response_deserializer=backend__pb2.StoresFindResult.FromString,
                _registered_method=True)
        self.Rerank = channel.unary_unary(
                '/backend.Backend/Rerank',
                request_serializer=backend__pb2.RerankRequest.SerializeToString,
                response_deserializer=backend__pb2.RerankResult.FromString,
                _registered_method=True)
        self.TokenClassify = channel.unary_unary(
                '/backend.Backend/TokenClassify',
                request_serializer=backend__pb2.TokenClassifyRequest.SerializeToString,
                response_deserializer=backend__pb2.TokenClassifyResponse.FromString,
                _registered_method=True)
        self.Score = channel.unary_unary(
                '/backend.Backend/Score',
                request_serializer=backend__pb2.ScoreRequest.SerializeToString,
                response_deserializer=backend__pb2.ScoreResponse.FromString,
                _registered_method=True)
        self.GetMetrics = channel.unary_unary(
                '/backend.Backend/GetMetrics',
                request_serializer=backend__pb2.MetricsRequest.SerializeToString,
                response_deserializer=backend__pb2.MetricsResponse.FromString,
                _registered_method=True)
        self.VAD = channel.unary_unary(
                '/backend.Backend/VAD',
                request_serializer=backend__pb2.VADRequest.SerializeToString,
                response_deserializer=backend__pb2.VADResponse.FromString,
                _registered_method=True)
        self.Diarize = channel.unary_unary(
                '/backend.Backend/Diarize',
                request_serializer=backend__pb2.DiarizeRequest.SerializeToString,
                response_deserializer=backend__pb2.DiarizeResponse.FromString,
                _registered_method=True)
        self.AudioEncode = channel.unary_unary(
                '/backend.Backend/AudioEncode',
                request_serializer=backend__pb2.AudioEncodeRequest.SerializeToString,
                response_deserializer=backend__pb2.AudioEncodeResult.FromString,
                _registered_method=True)
        self.AudioDecode = channel.unary_unary(
                '/backend.Backend/AudioDecode',
                request_serializer=backend__pb2.AudioDecodeRequest.SerializeToString,
                response_deserializer=backend__pb2.AudioDecodeResult.FromString,
                _registered_method=True)
        self.AudioTransform = channel.unary_unary(
                '/backend.Backend/AudioTransform',
                request_serializer=backend__pb2.AudioTransformRequest.SerializeToString,
                response_deserializer=backend__pb2.AudioTransformResult.FromString,
                _registered_method=True)
        self.AudioTransformStream = channel.stream_stream(
                '/backend.Backend/AudioTransformStream',
                request_serializer=backend__pb2.AudioTransformFrameRequest.SerializeToString,
                response_deserializer=backend__pb2.AudioTransformFrameResponse.FromString,
                _registered_method=True)
        self.AudioToAudioStream = channel.stream_stream(
                '/backend.Backend/AudioToAudioStream',
                request_serializer=backend__pb2.AudioToAudioRequest.SerializeToString,
                response_deserializer=backend__pb2.AudioToAudioResponse.FromString,
                _registered_method=True)
        self.ModelMetadata = channel.unary_unary(
                '/backend.Backend/ModelMetadata',
                request_serializer=backend__pb2.ModelOptions.SerializeToString,
                response_deserializer=backend__pb2.ModelMetadataResponse.FromString,
                _registered_method=True)
        self.StartFineTune = channel.unary_unary(
                '/backend.Backend/StartFineTune',
                request_serializer=backend__pb2.FineTuneRequest.SerializeToString,
                response_deserializer=backend__pb2.FineTuneJobResult.FromString,
                _registered_method=True)
        self.FineTuneProgress = channel.unary_stream(
                '/backend.Backend/FineTuneProgress',
                request_serializer=backend__pb2.FineTuneProgressRequest.SerializeToString,
                response_deserializer=backend__pb2.FineTuneProgressUpdate.FromString,
                _registered_method=True)
        self.StopFineTune = channel.unary_unary(
                '/backend.Backend/StopFineTune',
                request_serializer=backend__pb2.FineTuneStopRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.ListCheckpoints = channel.unary_unary(
                '/backend.Backend/ListCheckpoints',
                request_serializer=backend__pb2.ListCheckpointsRequest.SerializeToString,
                response_deserializer=backend__pb2.ListCheckpointsResponse.FromString,
                _registered_method=True)
        self.ExportModel = channel.unary_unary(
                '/backend.Backend/ExportModel',
                request_serializer=backend__pb2.ExportModelRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.StartQuantization = channel.unary_unary(
                '/backend.Backend/StartQuantization',
                request_serializer=backend__pb2.QuantizationRequest.SerializeToString,
                response_deserializer=backend__pb2.QuantizationJobResult.FromString,
                _registered_method=True)
        self.QuantizationProgress = channel.unary_stream(
                '/backend.Backend/QuantizationProgress',
                request_serializer=backend__pb2.QuantizationProgressRequest.SerializeToString,
                response_deserializer=backend__pb2.QuantizationProgressUpdate.FromString,
                _registered_method=True)
        self.StopQuantization = channel.unary_unary(
                '/backend.Backend/StopQuantization',
                request_serializer=backend__pb2.QuantizationStopRequest.SerializeToString,
                response_deserializer=backend__pb2.Result.FromString,
                _registered_method=True)
        self.Forward = channel.stream_stream(
                '/backend.Backend/Forward',
                request_serializer=backend__pb2.ForwardRequest.SerializeToString,
                response_deserializer=backend__pb2.ForwardReply.FromString,
                _registered_method=True)


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

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

    def Free(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 Predict(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 LoadModel(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 PredictStream(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 Embedding(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 GenerateImage(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 GenerateVideo(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 AudioTranscription(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 AudioTranscriptionStream(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 TTS(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 TTSStream(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 SoundGeneration(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 TokenizeString(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 Status(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 Detect(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 FaceVerify(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 FaceAnalyze(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 VoiceVerify(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 VoiceAnalyze(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 VoiceEmbed(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 StoresSet(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 StoresDelete(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 StoresGet(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 StoresFind(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 Rerank(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 TokenClassify(self, request, context):
        """TokenClassify runs a token-classification (NER) model on the
        supplied text and returns each detected entity span. Used by the
        PII redactor's optional NER tier — the regex tier still handles
        formatted hits cheaply, while this catches names, locations, and
        other unformatted PII that regex misses.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Score(self, request, context):
        """Score evaluates the model's joint log-probability of each
        supplied candidate continuation given a shared prompt. The
        prompt's KV cache is computed once and reused across candidates.
        Used for routing-policy multi-label classification, reranking,
        calibrated confidence, and reward-model scoring — any task where
        the consumer wants the model's confidence in a pre-specified
        continuation rather than a generated one.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMetrics(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 VAD(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 Diarize(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 AudioEncode(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 AudioDecode(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 AudioTransform(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 AudioTransformStream(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 AudioToAudioStream(self, request_iterator, context):
        """AudioToAudioStream is the bidirectional any-to-any S2S RPC. Backends
        that load a speech-to-speech model consume input audio frames and emit
        interleaved audio + transcript + tool-call deltas as typed events.
        Backends without S2S support return UNIMPLEMENTED.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ModelMetadata(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 StartFineTune(self, request, context):
        """Fine-tuning RPCs
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FineTuneProgress(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 StopFineTune(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 ListCheckpoints(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 ExportModel(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 StartQuantization(self, request, context):
        """Quantization RPCs
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def QuantizationProgress(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 StopQuantization(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 Forward(self, request_iterator, context):
        """Forward proxies a raw HTTP request to an upstream provider. The
        cloud-proxy backend implements this for passthrough-mode model
        configs: the client wire format is preserved end-to-end (no
        translation through internal proto), which means new provider
        fields work the day they ship. Translation-mode proxies use the
        standard Predict/PredictStream RPCs instead. Backends that don't
        support this return UNIMPLEMENTED.

        The request is bidirectionally streamed so large bodies can flow
        without buffering. In practice the first ForwardRequest carries
        path, method, headers, and the initial body chunk; subsequent
        messages append body chunks. The first ForwardReply carries the
        upstream status and response headers; subsequent messages stream
        body chunks (SSE frames or chunked transfer). Cancellation of the
        gRPC context closes the upstream connection.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_BackendServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Health': grpc.unary_unary_rpc_method_handler(
                    servicer.Health,
                    request_deserializer=backend__pb2.HealthMessage.FromString,
                    response_serializer=backend__pb2.Reply.SerializeToString,
            ),
            'Free': grpc.unary_unary_rpc_method_handler(
                    servicer.Free,
                    request_deserializer=backend__pb2.HealthMessage.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'Predict': grpc.unary_unary_rpc_method_handler(
                    servicer.Predict,
                    request_deserializer=backend__pb2.PredictOptions.FromString,
                    response_serializer=backend__pb2.Reply.SerializeToString,
            ),
            'LoadModel': grpc.unary_unary_rpc_method_handler(
                    servicer.LoadModel,
                    request_deserializer=backend__pb2.ModelOptions.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'PredictStream': grpc.unary_stream_rpc_method_handler(
                    servicer.PredictStream,
                    request_deserializer=backend__pb2.PredictOptions.FromString,
                    response_serializer=backend__pb2.Reply.SerializeToString,
            ),
            'Embedding': grpc.unary_unary_rpc_method_handler(
                    servicer.Embedding,
                    request_deserializer=backend__pb2.PredictOptions.FromString,
                    response_serializer=backend__pb2.EmbeddingResult.SerializeToString,
            ),
            'GenerateImage': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateImage,
                    request_deserializer=backend__pb2.GenerateImageRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'GenerateVideo': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateVideo,
                    request_deserializer=backend__pb2.GenerateVideoRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'AudioTranscription': grpc.unary_unary_rpc_method_handler(
                    servicer.AudioTranscription,
                    request_deserializer=backend__pb2.TranscriptRequest.FromString,
                    response_serializer=backend__pb2.TranscriptResult.SerializeToString,
            ),
            'AudioTranscriptionStream': grpc.unary_stream_rpc_method_handler(
                    servicer.AudioTranscriptionStream,
                    request_deserializer=backend__pb2.TranscriptRequest.FromString,
                    response_serializer=backend__pb2.TranscriptStreamResponse.SerializeToString,
            ),
            'TTS': grpc.unary_unary_rpc_method_handler(
                    servicer.TTS,
                    request_deserializer=backend__pb2.TTSRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'TTSStream': grpc.unary_stream_rpc_method_handler(
                    servicer.TTSStream,
                    request_deserializer=backend__pb2.TTSRequest.FromString,
                    response_serializer=backend__pb2.Reply.SerializeToString,
            ),
            'SoundGeneration': grpc.unary_unary_rpc_method_handler(
                    servicer.SoundGeneration,
                    request_deserializer=backend__pb2.SoundGenerationRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'TokenizeString': grpc.unary_unary_rpc_method_handler(
                    servicer.TokenizeString,
                    request_deserializer=backend__pb2.PredictOptions.FromString,
                    response_serializer=backend__pb2.TokenizationResponse.SerializeToString,
            ),
            'Status': grpc.unary_unary_rpc_method_handler(
                    servicer.Status,
                    request_deserializer=backend__pb2.HealthMessage.FromString,
                    response_serializer=backend__pb2.StatusResponse.SerializeToString,
            ),
            'Detect': grpc.unary_unary_rpc_method_handler(
                    servicer.Detect,
                    request_deserializer=backend__pb2.DetectOptions.FromString,
                    response_serializer=backend__pb2.DetectResponse.SerializeToString,
            ),
            'FaceVerify': grpc.unary_unary_rpc_method_handler(
                    servicer.FaceVerify,
                    request_deserializer=backend__pb2.FaceVerifyRequest.FromString,
                    response_serializer=backend__pb2.FaceVerifyResponse.SerializeToString,
            ),
            'FaceAnalyze': grpc.unary_unary_rpc_method_handler(
                    servicer.FaceAnalyze,
                    request_deserializer=backend__pb2.FaceAnalyzeRequest.FromString,
                    response_serializer=backend__pb2.FaceAnalyzeResponse.SerializeToString,
            ),
            'VoiceVerify': grpc.unary_unary_rpc_method_handler(
                    servicer.VoiceVerify,
                    request_deserializer=backend__pb2.VoiceVerifyRequest.FromString,
                    response_serializer=backend__pb2.VoiceVerifyResponse.SerializeToString,
            ),
            'VoiceAnalyze': grpc.unary_unary_rpc_method_handler(
                    servicer.VoiceAnalyze,
                    request_deserializer=backend__pb2.VoiceAnalyzeRequest.FromString,
                    response_serializer=backend__pb2.VoiceAnalyzeResponse.SerializeToString,
            ),
            'VoiceEmbed': grpc.unary_unary_rpc_method_handler(
                    servicer.VoiceEmbed,
                    request_deserializer=backend__pb2.VoiceEmbedRequest.FromString,
                    response_serializer=backend__pb2.VoiceEmbedResponse.SerializeToString,
            ),
            'StoresSet': grpc.unary_unary_rpc_method_handler(
                    servicer.StoresSet,
                    request_deserializer=backend__pb2.StoresSetOptions.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'StoresDelete': grpc.unary_unary_rpc_method_handler(
                    servicer.StoresDelete,
                    request_deserializer=backend__pb2.StoresDeleteOptions.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'StoresGet': grpc.unary_unary_rpc_method_handler(
                    servicer.StoresGet,
                    request_deserializer=backend__pb2.StoresGetOptions.FromString,
                    response_serializer=backend__pb2.StoresGetResult.SerializeToString,
            ),
            'StoresFind': grpc.unary_unary_rpc_method_handler(
                    servicer.StoresFind,
                    request_deserializer=backend__pb2.StoresFindOptions.FromString,
                    response_serializer=backend__pb2.StoresFindResult.SerializeToString,
            ),
            'Rerank': grpc.unary_unary_rpc_method_handler(
                    servicer.Rerank,
                    request_deserializer=backend__pb2.RerankRequest.FromString,
                    response_serializer=backend__pb2.RerankResult.SerializeToString,
            ),
            'TokenClassify': grpc.unary_unary_rpc_method_handler(
                    servicer.TokenClassify,
                    request_deserializer=backend__pb2.TokenClassifyRequest.FromString,
                    response_serializer=backend__pb2.TokenClassifyResponse.SerializeToString,
            ),
            'Score': grpc.unary_unary_rpc_method_handler(
                    servicer.Score,
                    request_deserializer=backend__pb2.ScoreRequest.FromString,
                    response_serializer=backend__pb2.ScoreResponse.SerializeToString,
            ),
            'GetMetrics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMetrics,
                    request_deserializer=backend__pb2.MetricsRequest.FromString,
                    response_serializer=backend__pb2.MetricsResponse.SerializeToString,
            ),
            'VAD': grpc.unary_unary_rpc_method_handler(
                    servicer.VAD,
                    request_deserializer=backend__pb2.VADRequest.FromString,
                    response_serializer=backend__pb2.VADResponse.SerializeToString,
            ),
            'Diarize': grpc.unary_unary_rpc_method_handler(
                    servicer.Diarize,
                    request_deserializer=backend__pb2.DiarizeRequest.FromString,
                    response_serializer=backend__pb2.DiarizeResponse.SerializeToString,
            ),
            'AudioEncode': grpc.unary_unary_rpc_method_handler(
                    servicer.AudioEncode,
                    request_deserializer=backend__pb2.AudioEncodeRequest.FromString,
                    response_serializer=backend__pb2.AudioEncodeResult.SerializeToString,
            ),
            'AudioDecode': grpc.unary_unary_rpc_method_handler(
                    servicer.AudioDecode,
                    request_deserializer=backend__pb2.AudioDecodeRequest.FromString,
                    response_serializer=backend__pb2.AudioDecodeResult.SerializeToString,
            ),
            'AudioTransform': grpc.unary_unary_rpc_method_handler(
                    servicer.AudioTransform,
                    request_deserializer=backend__pb2.AudioTransformRequest.FromString,
                    response_serializer=backend__pb2.AudioTransformResult.SerializeToString,
            ),
            'AudioTransformStream': grpc.stream_stream_rpc_method_handler(
                    servicer.AudioTransformStream,
                    request_deserializer=backend__pb2.AudioTransformFrameRequest.FromString,
                    response_serializer=backend__pb2.AudioTransformFrameResponse.SerializeToString,
            ),
            'AudioToAudioStream': grpc.stream_stream_rpc_method_handler(
                    servicer.AudioToAudioStream,
                    request_deserializer=backend__pb2.AudioToAudioRequest.FromString,
                    response_serializer=backend__pb2.AudioToAudioResponse.SerializeToString,
            ),
            'ModelMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.ModelMetadata,
                    request_deserializer=backend__pb2.ModelOptions.FromString,
                    response_serializer=backend__pb2.ModelMetadataResponse.SerializeToString,
            ),
            'StartFineTune': grpc.unary_unary_rpc_method_handler(
                    servicer.StartFineTune,
                    request_deserializer=backend__pb2.FineTuneRequest.FromString,
                    response_serializer=backend__pb2.FineTuneJobResult.SerializeToString,
            ),
            'FineTuneProgress': grpc.unary_stream_rpc_method_handler(
                    servicer.FineTuneProgress,
                    request_deserializer=backend__pb2.FineTuneProgressRequest.FromString,
                    response_serializer=backend__pb2.FineTuneProgressUpdate.SerializeToString,
            ),
            'StopFineTune': grpc.unary_unary_rpc_method_handler(
                    servicer.StopFineTune,
                    request_deserializer=backend__pb2.FineTuneStopRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'ListCheckpoints': grpc.unary_unary_rpc_method_handler(
                    servicer.ListCheckpoints,
                    request_deserializer=backend__pb2.ListCheckpointsRequest.FromString,
                    response_serializer=backend__pb2.ListCheckpointsResponse.SerializeToString,
            ),
            'ExportModel': grpc.unary_unary_rpc_method_handler(
                    servicer.ExportModel,
                    request_deserializer=backend__pb2.ExportModelRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'StartQuantization': grpc.unary_unary_rpc_method_handler(
                    servicer.StartQuantization,
                    request_deserializer=backend__pb2.QuantizationRequest.FromString,
                    response_serializer=backend__pb2.QuantizationJobResult.SerializeToString,
            ),
            'QuantizationProgress': grpc.unary_stream_rpc_method_handler(
                    servicer.QuantizationProgress,
                    request_deserializer=backend__pb2.QuantizationProgressRequest.FromString,
                    response_serializer=backend__pb2.QuantizationProgressUpdate.SerializeToString,
            ),
            'StopQuantization': grpc.unary_unary_rpc_method_handler(
                    servicer.StopQuantization,
                    request_deserializer=backend__pb2.QuantizationStopRequest.FromString,
                    response_serializer=backend__pb2.Result.SerializeToString,
            ),
            'Forward': grpc.stream_stream_rpc_method_handler(
                    servicer.Forward,
                    request_deserializer=backend__pb2.ForwardRequest.FromString,
                    response_serializer=backend__pb2.ForwardReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'backend.Backend', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('backend.Backend', rpc_method_handlers)


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

    @staticmethod
    def Health(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/backend.Backend/Health',
            backend__pb2.HealthMessage.SerializeToString,
            backend__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Free(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,
            '/backend.Backend/Free',
            backend__pb2.HealthMessage.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Predict(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,
            '/backend.Backend/Predict',
            backend__pb2.PredictOptions.SerializeToString,
            backend__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LoadModel(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,
            '/backend.Backend/LoadModel',
            backend__pb2.ModelOptions.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PredictStream(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,
            '/backend.Backend/PredictStream',
            backend__pb2.PredictOptions.SerializeToString,
            backend__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Embedding(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,
            '/backend.Backend/Embedding',
            backend__pb2.PredictOptions.SerializeToString,
            backend__pb2.EmbeddingResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GenerateImage(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,
            '/backend.Backend/GenerateImage',
            backend__pb2.GenerateImageRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GenerateVideo(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,
            '/backend.Backend/GenerateVideo',
            backend__pb2.GenerateVideoRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioTranscription(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,
            '/backend.Backend/AudioTranscription',
            backend__pb2.TranscriptRequest.SerializeToString,
            backend__pb2.TranscriptResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioTranscriptionStream(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,
            '/backend.Backend/AudioTranscriptionStream',
            backend__pb2.TranscriptRequest.SerializeToString,
            backend__pb2.TranscriptStreamResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TTS(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,
            '/backend.Backend/TTS',
            backend__pb2.TTSRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TTSStream(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,
            '/backend.Backend/TTSStream',
            backend__pb2.TTSRequest.SerializeToString,
            backend__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SoundGeneration(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,
            '/backend.Backend/SoundGeneration',
            backend__pb2.SoundGenerationRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TokenizeString(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,
            '/backend.Backend/TokenizeString',
            backend__pb2.PredictOptions.SerializeToString,
            backend__pb2.TokenizationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Status(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,
            '/backend.Backend/Status',
            backend__pb2.HealthMessage.SerializeToString,
            backend__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Detect(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,
            '/backend.Backend/Detect',
            backend__pb2.DetectOptions.SerializeToString,
            backend__pb2.DetectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FaceVerify(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,
            '/backend.Backend/FaceVerify',
            backend__pb2.FaceVerifyRequest.SerializeToString,
            backend__pb2.FaceVerifyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FaceAnalyze(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,
            '/backend.Backend/FaceAnalyze',
            backend__pb2.FaceAnalyzeRequest.SerializeToString,
            backend__pb2.FaceAnalyzeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VoiceVerify(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,
            '/backend.Backend/VoiceVerify',
            backend__pb2.VoiceVerifyRequest.SerializeToString,
            backend__pb2.VoiceVerifyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VoiceAnalyze(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,
            '/backend.Backend/VoiceAnalyze',
            backend__pb2.VoiceAnalyzeRequest.SerializeToString,
            backend__pb2.VoiceAnalyzeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VoiceEmbed(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,
            '/backend.Backend/VoiceEmbed',
            backend__pb2.VoiceEmbedRequest.SerializeToString,
            backend__pb2.VoiceEmbedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoresSet(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,
            '/backend.Backend/StoresSet',
            backend__pb2.StoresSetOptions.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoresDelete(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,
            '/backend.Backend/StoresDelete',
            backend__pb2.StoresDeleteOptions.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoresGet(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,
            '/backend.Backend/StoresGet',
            backend__pb2.StoresGetOptions.SerializeToString,
            backend__pb2.StoresGetResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoresFind(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,
            '/backend.Backend/StoresFind',
            backend__pb2.StoresFindOptions.SerializeToString,
            backend__pb2.StoresFindResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Rerank(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,
            '/backend.Backend/Rerank',
            backend__pb2.RerankRequest.SerializeToString,
            backend__pb2.RerankResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TokenClassify(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,
            '/backend.Backend/TokenClassify',
            backend__pb2.TokenClassifyRequest.SerializeToString,
            backend__pb2.TokenClassifyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Score(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,
            '/backend.Backend/Score',
            backend__pb2.ScoreRequest.SerializeToString,
            backend__pb2.ScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMetrics(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,
            '/backend.Backend/GetMetrics',
            backend__pb2.MetricsRequest.SerializeToString,
            backend__pb2.MetricsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VAD(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,
            '/backend.Backend/VAD',
            backend__pb2.VADRequest.SerializeToString,
            backend__pb2.VADResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Diarize(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,
            '/backend.Backend/Diarize',
            backend__pb2.DiarizeRequest.SerializeToString,
            backend__pb2.DiarizeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioEncode(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,
            '/backend.Backend/AudioEncode',
            backend__pb2.AudioEncodeRequest.SerializeToString,
            backend__pb2.AudioEncodeResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioDecode(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,
            '/backend.Backend/AudioDecode',
            backend__pb2.AudioDecodeRequest.SerializeToString,
            backend__pb2.AudioDecodeResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioTransform(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,
            '/backend.Backend/AudioTransform',
            backend__pb2.AudioTransformRequest.SerializeToString,
            backend__pb2.AudioTransformResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioTransformStream(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,
            '/backend.Backend/AudioTransformStream',
            backend__pb2.AudioTransformFrameRequest.SerializeToString,
            backend__pb2.AudioTransformFrameResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AudioToAudioStream(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,
            '/backend.Backend/AudioToAudioStream',
            backend__pb2.AudioToAudioRequest.SerializeToString,
            backend__pb2.AudioToAudioResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ModelMetadata(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,
            '/backend.Backend/ModelMetadata',
            backend__pb2.ModelOptions.SerializeToString,
            backend__pb2.ModelMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartFineTune(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,
            '/backend.Backend/StartFineTune',
            backend__pb2.FineTuneRequest.SerializeToString,
            backend__pb2.FineTuneJobResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FineTuneProgress(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,
            '/backend.Backend/FineTuneProgress',
            backend__pb2.FineTuneProgressRequest.SerializeToString,
            backend__pb2.FineTuneProgressUpdate.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopFineTune(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,
            '/backend.Backend/StopFineTune',
            backend__pb2.FineTuneStopRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListCheckpoints(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,
            '/backend.Backend/ListCheckpoints',
            backend__pb2.ListCheckpointsRequest.SerializeToString,
            backend__pb2.ListCheckpointsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExportModel(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,
            '/backend.Backend/ExportModel',
            backend__pb2.ExportModelRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartQuantization(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,
            '/backend.Backend/StartQuantization',
            backend__pb2.QuantizationRequest.SerializeToString,
            backend__pb2.QuantizationJobResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def QuantizationProgress(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,
            '/backend.Backend/QuantizationProgress',
            backend__pb2.QuantizationProgressRequest.SerializeToString,
            backend__pb2.QuantizationProgressUpdate.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopQuantization(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,
            '/backend.Backend/StopQuantization',
            backend__pb2.QuantizationStopRequest.SerializeToString,
            backend__pb2.Result.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Forward(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,
            '/backend.Backend/Forward',
            backend__pb2.ForwardRequest.SerializeToString,
            backend__pb2.ForwardReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)