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

from . import spm_pb2 as spm__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Noop = channel.unary_unary(
                '/SPM/Noop',
                request_serializer=spm__pb2.NoopContent.SerializeToString,
                response_deserializer=spm__pb2.NoopContent.FromString,
                )
        self.GetDataSetClosed = channel.unary_unary(
                '/SPM/GetDataSetClosed',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.Closed.FromString,
                )
        self.ClearData = channel.unary_unary(
                '/SPM/ClearData',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.ReadData = channel.unary_stream(
                '/SPM/ReadData',
                request_serializer=spm__pb2.ReadScenario.SerializeToString,
                response_deserializer=spm__pb2.DataList.FromString,
                )
        self.CloseData = channel.unary_unary(
                '/SPM/CloseData',
                request_serializer=spm__pb2.DataCompleted.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.ClearDataTags = channel.unary_unary(
                '/SPM/ClearDataTags',
                request_serializer=spm__pb2.ScenarioDataTags.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.WriteDataList = channel.stream_stream(
                '/SPM/WriteDataList',
                request_serializer=spm__pb2.IndexedDataList.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.PushDataList = channel.unary_unary(
                '/SPM/PushDataList',
                request_serializer=spm__pb2.IndexedDataList.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.SetOptimizationResult = channel.unary_unary(
                '/SPM/SetOptimizationResult',
                request_serializer=spm__pb2.SetOptimizationResultRequest.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.SetOptimizationIterationScore = channel.unary_unary(
                '/SPM/SetOptimizationIterationScore',
                request_serializer=spm__pb2.SetOptimizationIterationScoreRequest.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.GetScenarioMetaData = channel.unary_unary(
                '/SPM/GetScenarioMetaData',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.ScenarioMetaData.FromString,
                )
        self.SetScenarioMetaData = channel.unary_unary(
                '/SPM/SetScenarioMetaData',
                request_serializer=spm__pb2.ScenarioMetaData.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.GetScenarioCustomMetaData = channel.unary_unary(
                '/SPM/GetScenarioCustomMetaData',
                request_serializer=spm__pb2.ScenarioCustomMetaData.SerializeToString,
                response_deserializer=spm__pb2.ScenarioCustomMetaData.FromString,
                )
        self.SetScenarioCustomMetaData = channel.unary_unary(
                '/SPM/SetScenarioCustomMetaData',
                request_serializer=spm__pb2.ScenarioCustomMetaData.SerializeToString,
                response_deserializer=spm__pb2.ScenarioCustomMetaData.FromString,
                )
        self.GetScenarioDataStats = channel.unary_unary(
                '/SPM/GetScenarioDataStats',
                request_serializer=spm__pb2.ScenarioStatsRequest.SerializeToString,
                response_deserializer=spm__pb2.ScenarioStats.FromString,
                )
        self.GetModel = channel.unary_unary(
                '/SPM/GetModel',
                request_serializer=spm__pb2.Model.SerializeToString,
                response_deserializer=spm__pb2.Model.FromString,
                )
        self.DuplicateScenario = channel.unary_unary(
                '/SPM/DuplicateScenario',
                request_serializer=spm__pb2.DuplicateScenarioRequest.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.PushExecutionLogEntries = channel.unary_unary(
                '/SPM/PushExecutionLogEntries',
                request_serializer=spm__pb2.LogEntries.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.ReadExecutionLogEntries = channel.unary_stream(
                '/SPM/ReadExecutionLogEntries',
                request_serializer=spm__pb2.ExecutionReadLogs.SerializeToString,
                response_deserializer=spm__pb2.ExeLogEntry.FromString,
                )
        self.GetScenario = channel.unary_unary(
                '/SPM/GetScenario',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.ScenarioDocument.FromString,
                )
        self.SetScenarioResultDocument = channel.unary_unary(
                '/SPM/SetScenarioResultDocument',
                request_serializer=spm__pb2.ScenarioResultsDocument.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.GetScenarioResultDocument = channel.unary_unary(
                '/SPM/GetScenarioResultDocument',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.ScenarioResultsDocument.FromString,
                )
        self.GetUser = channel.unary_unary(
                '/SPM/GetUser',
                request_serializer=spm__pb2.UserRequest.SerializeToString,
                response_deserializer=spm__pb2.User.FromString,
                )
        self.GetGroup = channel.unary_unary(
                '/SPM/GetGroup',
                request_serializer=spm__pb2.Group.SerializeToString,
                response_deserializer=spm__pb2.GroupDocument.FromString,
                )
        self.GetProject = channel.unary_unary(
                '/SPM/GetProject',
                request_serializer=spm__pb2.Project.SerializeToString,
                response_deserializer=spm__pb2.ProjectDocument.FromString,
                )
        self.DeleteScenario = channel.unary_unary(
                '/SPM/DeleteScenario',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.DeleteProject = channel.unary_unary(
                '/SPM/DeleteProject',
                request_serializer=spm__pb2.Project.SerializeToString,
                response_deserializer=spm__pb2.Project.FromString,
                )
        self.DeleteSystem = channel.unary_unary(
                '/SPM/DeleteSystem',
                request_serializer=spm__pb2.SystemRequest.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.DeleteUser = channel.unary_unary(
                '/SPM/DeleteUser',
                request_serializer=spm__pb2.UserRequest.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.ListenScenario = channel.unary_stream(
                '/SPM/ListenScenario',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.ScenarioDocument.FromString,
                )
        self.SetScenarioProgress = channel.unary_unary(
                '/SPM/SetScenarioProgress',
                request_serializer=spm__pb2.ScenarioProgress.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.SetScenarioDataTags = channel.unary_unary(
                '/SPM/SetScenarioDataTags',
                request_serializer=spm__pb2.ScenarioDataTags.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.PushScenarioError = channel.unary_unary(
                '/SPM/PushScenarioError',
                request_serializer=spm__pb2.ScenarioError.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.PushScenarioFormattedError = channel.unary_unary(
                '/SPM/PushScenarioFormattedError',
                request_serializer=spm__pb2.ScenarioFormattedError.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.GetSignedURLs = channel.unary_unary(
                '/SPM/GetSignedURLs',
                request_serializer=spm__pb2.FilePaths.SerializeToString,
                response_deserializer=spm__pb2.FileSignedUrls.FromString,
                )
        self.GetPublicLink = channel.unary_unary(
                '/SPM/GetPublicLink',
                request_serializer=spm__pb2.Link.SerializeToString,
                response_deserializer=spm__pb2.SignedUrl.FromString,
                )
        self.GenerateScenarioUploadSignedURL = channel.unary_unary(
                '/SPM/GenerateScenarioUploadSignedURL',
                request_serializer=spm__pb2.ScenarioFilePath.SerializeToString,
                response_deserializer=spm__pb2.ScenarioUploadURL.FromString,
                )
        self.ClearScenarioResults = channel.unary_unary(
                '/SPM/ClearScenarioResults',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.SetScenarioResults = channel.unary_unary(
                '/SPM/SetScenarioResults',
                request_serializer=spm__pb2.ScenarioResults.SerializeToString,
                response_deserializer=spm__pb2.Scenario.FromString,
                )
        self.GetScenarioResults = channel.unary_unary(
                '/SPM/GetScenarioResults',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.ScenarioResults.FromString,
                )
        self.SubscribeForUpdates = channel.unary_stream(
                '/SPM/SubscribeForUpdates',
                request_serializer=spm__pb2.Subscription.SerializeToString,
                response_deserializer=spm__pb2.SubscriptionMessage.FromString,
                )
        self.PublishSubscriptionMessage = channel.unary_unary(
                '/SPM/PublishSubscriptionMessage',
                request_serializer=spm__pb2.SubscriptionMessage.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.CompleteExecution = channel.unary_unary(
                '/SPM/CompleteExecution',
                request_serializer=spm__pb2.CompleteExecutionMessage.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.CompleteExecutionIgnoreInstance = channel.unary_unary(
                '/SPM/CompleteExecutionIgnoreInstance',
                request_serializer=spm__pb2.ExecutionMessage.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.UpdateExecution = channel.unary_unary(
                '/SPM/UpdateExecution',
                request_serializer=spm__pb2.Json.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.ClearExecutionMemory = channel.unary_unary(
                '/SPM/ClearExecutionMemory',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.RemoveExecutionData = channel.unary_unary(
                '/SPM/RemoveExecutionData',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.GetLatestMainExecution = channel.unary_unary(
                '/SPM/GetLatestMainExecution',
                request_serializer=spm__pb2.Scenario.SerializeToString,
                response_deserializer=spm__pb2.ExecutionId.FromString,
                )
        self.UpdateProbe = channel.unary_unary(
                '/SPM/UpdateProbe',
                request_serializer=spm__pb2.ProbeInformation.SerializeToString,
                response_deserializer=spm__pb2.ProbeResponse.FromString,
                )
        self.WriteDataStream = channel.stream_stream(
                '/SPM/WriteDataStream',
                request_serializer=spm__pb2.WriteDataStreamRequest.SerializeToString,
                response_deserializer=spm__pb2.WriteDataStreamResponse.FromString,
                )
        self.ReadDataStream = channel.stream_stream(
                '/SPM/ReadDataStream',
                request_serializer=spm__pb2.ReadDataStreamRequest.SerializeToString,
                response_deserializer=spm__pb2.ReadDataStreamResponse.FromString,
                )
        self.GetDataStreamStats = channel.unary_unary(
                '/SPM/GetDataStreamStats',
                request_serializer=spm__pb2.GetDataStreamStatsRequest.SerializeToString,
                response_deserializer=spm__pb2.GetDataStreamStatsResponse.FromString,
                )


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

    def Noop(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 GetDataSetClosed(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 ClearData(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 ReadData(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 CloseData(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 ClearDataTags(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 WriteDataList(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 PushDataList(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 SetOptimizationResult(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 SetOptimizationIterationScore(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 GetScenarioMetaData(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 SetScenarioMetaData(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 GetScenarioCustomMetaData(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 SetScenarioCustomMetaData(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 GetScenarioDataStats(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 GetModel(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 DuplicateScenario(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 PushExecutionLogEntries(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 ReadExecutionLogEntries(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 GetScenario(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 SetScenarioResultDocument(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 GetScenarioResultDocument(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 GetUser(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 GetGroup(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 GetProject(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 DeleteScenario(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 DeleteProject(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 DeleteSystem(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 DeleteUser(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 ListenScenario(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 SetScenarioProgress(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 SetScenarioDataTags(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 PushScenarioError(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 PushScenarioFormattedError(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 GetSignedURLs(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 GetPublicLink(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 GenerateScenarioUploadSignedURL(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 ClearScenarioResults(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 SetScenarioResults(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 GetScenarioResults(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 SubscribeForUpdates(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 PublishSubscriptionMessage(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 CompleteExecution(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 CompleteExecutionIgnoreInstance(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 UpdateExecution(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 ClearExecutionMemory(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 RemoveExecutionData(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 GetLatestMainExecution(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 UpdateProbe(self, request, context):
        """Garbage collection
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WriteDataStream(self, request_iterator, context):
        """Data-Port stream wrapper
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReadDataStream(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 GetDataStreamStats(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_SPMServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Noop': grpc.unary_unary_rpc_method_handler(
                    servicer.Noop,
                    request_deserializer=spm__pb2.NoopContent.FromString,
                    response_serializer=spm__pb2.NoopContent.SerializeToString,
            ),
            'GetDataSetClosed': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDataSetClosed,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.Closed.SerializeToString,
            ),
            'ClearData': grpc.unary_unary_rpc_method_handler(
                    servicer.ClearData,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'ReadData': grpc.unary_stream_rpc_method_handler(
                    servicer.ReadData,
                    request_deserializer=spm__pb2.ReadScenario.FromString,
                    response_serializer=spm__pb2.DataList.SerializeToString,
            ),
            'CloseData': grpc.unary_unary_rpc_method_handler(
                    servicer.CloseData,
                    request_deserializer=spm__pb2.DataCompleted.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'ClearDataTags': grpc.unary_unary_rpc_method_handler(
                    servicer.ClearDataTags,
                    request_deserializer=spm__pb2.ScenarioDataTags.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'WriteDataList': grpc.stream_stream_rpc_method_handler(
                    servicer.WriteDataList,
                    request_deserializer=spm__pb2.IndexedDataList.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'PushDataList': grpc.unary_unary_rpc_method_handler(
                    servicer.PushDataList,
                    request_deserializer=spm__pb2.IndexedDataList.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'SetOptimizationResult': grpc.unary_unary_rpc_method_handler(
                    servicer.SetOptimizationResult,
                    request_deserializer=spm__pb2.SetOptimizationResultRequest.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'SetOptimizationIterationScore': grpc.unary_unary_rpc_method_handler(
                    servicer.SetOptimizationIterationScore,
                    request_deserializer=spm__pb2.SetOptimizationIterationScoreRequest.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'GetScenarioMetaData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetScenarioMetaData,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.ScenarioMetaData.SerializeToString,
            ),
            'SetScenarioMetaData': grpc.unary_unary_rpc_method_handler(
                    servicer.SetScenarioMetaData,
                    request_deserializer=spm__pb2.ScenarioMetaData.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'GetScenarioCustomMetaData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetScenarioCustomMetaData,
                    request_deserializer=spm__pb2.ScenarioCustomMetaData.FromString,
                    response_serializer=spm__pb2.ScenarioCustomMetaData.SerializeToString,
            ),
            'SetScenarioCustomMetaData': grpc.unary_unary_rpc_method_handler(
                    servicer.SetScenarioCustomMetaData,
                    request_deserializer=spm__pb2.ScenarioCustomMetaData.FromString,
                    response_serializer=spm__pb2.ScenarioCustomMetaData.SerializeToString,
            ),
            'GetScenarioDataStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetScenarioDataStats,
                    request_deserializer=spm__pb2.ScenarioStatsRequest.FromString,
                    response_serializer=spm__pb2.ScenarioStats.SerializeToString,
            ),
            'GetModel': grpc.unary_unary_rpc_method_handler(
                    servicer.GetModel,
                    request_deserializer=spm__pb2.Model.FromString,
                    response_serializer=spm__pb2.Model.SerializeToString,
            ),
            'DuplicateScenario': grpc.unary_unary_rpc_method_handler(
                    servicer.DuplicateScenario,
                    request_deserializer=spm__pb2.DuplicateScenarioRequest.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'PushExecutionLogEntries': grpc.unary_unary_rpc_method_handler(
                    servicer.PushExecutionLogEntries,
                    request_deserializer=spm__pb2.LogEntries.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'ReadExecutionLogEntries': grpc.unary_stream_rpc_method_handler(
                    servicer.ReadExecutionLogEntries,
                    request_deserializer=spm__pb2.ExecutionReadLogs.FromString,
                    response_serializer=spm__pb2.ExeLogEntry.SerializeToString,
            ),
            'GetScenario': grpc.unary_unary_rpc_method_handler(
                    servicer.GetScenario,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.ScenarioDocument.SerializeToString,
            ),
            'SetScenarioResultDocument': grpc.unary_unary_rpc_method_handler(
                    servicer.SetScenarioResultDocument,
                    request_deserializer=spm__pb2.ScenarioResultsDocument.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'GetScenarioResultDocument': grpc.unary_unary_rpc_method_handler(
                    servicer.GetScenarioResultDocument,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.ScenarioResultsDocument.SerializeToString,
            ),
            'GetUser': grpc.unary_unary_rpc_method_handler(
                    servicer.GetUser,
                    request_deserializer=spm__pb2.UserRequest.FromString,
                    response_serializer=spm__pb2.User.SerializeToString,
            ),
            'GetGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.GetGroup,
                    request_deserializer=spm__pb2.Group.FromString,
                    response_serializer=spm__pb2.GroupDocument.SerializeToString,
            ),
            'GetProject': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProject,
                    request_deserializer=spm__pb2.Project.FromString,
                    response_serializer=spm__pb2.ProjectDocument.SerializeToString,
            ),
            'DeleteScenario': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteScenario,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'DeleteProject': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteProject,
                    request_deserializer=spm__pb2.Project.FromString,
                    response_serializer=spm__pb2.Project.SerializeToString,
            ),
            'DeleteSystem': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSystem,
                    request_deserializer=spm__pb2.SystemRequest.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'DeleteUser': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteUser,
                    request_deserializer=spm__pb2.UserRequest.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'ListenScenario': grpc.unary_stream_rpc_method_handler(
                    servicer.ListenScenario,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.ScenarioDocument.SerializeToString,
            ),
            'SetScenarioProgress': grpc.unary_unary_rpc_method_handler(
                    servicer.SetScenarioProgress,
                    request_deserializer=spm__pb2.ScenarioProgress.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'SetScenarioDataTags': grpc.unary_unary_rpc_method_handler(
                    servicer.SetScenarioDataTags,
                    request_deserializer=spm__pb2.ScenarioDataTags.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'PushScenarioError': grpc.unary_unary_rpc_method_handler(
                    servicer.PushScenarioError,
                    request_deserializer=spm__pb2.ScenarioError.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'PushScenarioFormattedError': grpc.unary_unary_rpc_method_handler(
                    servicer.PushScenarioFormattedError,
                    request_deserializer=spm__pb2.ScenarioFormattedError.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'GetSignedURLs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSignedURLs,
                    request_deserializer=spm__pb2.FilePaths.FromString,
                    response_serializer=spm__pb2.FileSignedUrls.SerializeToString,
            ),
            'GetPublicLink': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPublicLink,
                    request_deserializer=spm__pb2.Link.FromString,
                    response_serializer=spm__pb2.SignedUrl.SerializeToString,
            ),
            'GenerateScenarioUploadSignedURL': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateScenarioUploadSignedURL,
                    request_deserializer=spm__pb2.ScenarioFilePath.FromString,
                    response_serializer=spm__pb2.ScenarioUploadURL.SerializeToString,
            ),
            'ClearScenarioResults': grpc.unary_unary_rpc_method_handler(
                    servicer.ClearScenarioResults,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'SetScenarioResults': grpc.unary_unary_rpc_method_handler(
                    servicer.SetScenarioResults,
                    request_deserializer=spm__pb2.ScenarioResults.FromString,
                    response_serializer=spm__pb2.Scenario.SerializeToString,
            ),
            'GetScenarioResults': grpc.unary_unary_rpc_method_handler(
                    servicer.GetScenarioResults,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.ScenarioResults.SerializeToString,
            ),
            'SubscribeForUpdates': grpc.unary_stream_rpc_method_handler(
                    servicer.SubscribeForUpdates,
                    request_deserializer=spm__pb2.Subscription.FromString,
                    response_serializer=spm__pb2.SubscriptionMessage.SerializeToString,
            ),
            'PublishSubscriptionMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.PublishSubscriptionMessage,
                    request_deserializer=spm__pb2.SubscriptionMessage.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'CompleteExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.CompleteExecution,
                    request_deserializer=spm__pb2.CompleteExecutionMessage.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'CompleteExecutionIgnoreInstance': grpc.unary_unary_rpc_method_handler(
                    servicer.CompleteExecutionIgnoreInstance,
                    request_deserializer=spm__pb2.ExecutionMessage.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'UpdateExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateExecution,
                    request_deserializer=spm__pb2.Json.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'ClearExecutionMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.ClearExecutionMemory,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'RemoveExecutionData': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveExecutionData,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'GetLatestMainExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLatestMainExecution,
                    request_deserializer=spm__pb2.Scenario.FromString,
                    response_serializer=spm__pb2.ExecutionId.SerializeToString,
            ),
            'UpdateProbe': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateProbe,
                    request_deserializer=spm__pb2.ProbeInformation.FromString,
                    response_serializer=spm__pb2.ProbeResponse.SerializeToString,
            ),
            'WriteDataStream': grpc.stream_stream_rpc_method_handler(
                    servicer.WriteDataStream,
                    request_deserializer=spm__pb2.WriteDataStreamRequest.FromString,
                    response_serializer=spm__pb2.WriteDataStreamResponse.SerializeToString,
            ),
            'ReadDataStream': grpc.stream_stream_rpc_method_handler(
                    servicer.ReadDataStream,
                    request_deserializer=spm__pb2.ReadDataStreamRequest.FromString,
                    response_serializer=spm__pb2.ReadDataStreamResponse.SerializeToString,
            ),
            'GetDataStreamStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDataStreamStats,
                    request_deserializer=spm__pb2.GetDataStreamStatsRequest.FromString,
                    response_serializer=spm__pb2.GetDataStreamStatsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'SPM', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def Noop(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, '/SPM/Noop',
            spm__pb2.NoopContent.SerializeToString,
            spm__pb2.NoopContent.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDataSetClosed(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, '/SPM/GetDataSetClosed',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.Closed.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ClearData(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, '/SPM/ClearData',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReadData(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, '/SPM/ReadData',
            spm__pb2.ReadScenario.SerializeToString,
            spm__pb2.DataList.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CloseData(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, '/SPM/CloseData',
            spm__pb2.DataCompleted.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ClearDataTags(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, '/SPM/ClearDataTags',
            spm__pb2.ScenarioDataTags.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WriteDataList(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, '/SPM/WriteDataList',
            spm__pb2.IndexedDataList.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PushDataList(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, '/SPM/PushDataList',
            spm__pb2.IndexedDataList.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetOptimizationResult(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, '/SPM/SetOptimizationResult',
            spm__pb2.SetOptimizationResultRequest.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetOptimizationIterationScore(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, '/SPM/SetOptimizationIterationScore',
            spm__pb2.SetOptimizationIterationScoreRequest.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetScenarioMetaData(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, '/SPM/GetScenarioMetaData',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.ScenarioMetaData.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetScenarioMetaData(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, '/SPM/SetScenarioMetaData',
            spm__pb2.ScenarioMetaData.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetScenarioCustomMetaData(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, '/SPM/GetScenarioCustomMetaData',
            spm__pb2.ScenarioCustomMetaData.SerializeToString,
            spm__pb2.ScenarioCustomMetaData.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetScenarioCustomMetaData(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, '/SPM/SetScenarioCustomMetaData',
            spm__pb2.ScenarioCustomMetaData.SerializeToString,
            spm__pb2.ScenarioCustomMetaData.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetScenarioDataStats(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, '/SPM/GetScenarioDataStats',
            spm__pb2.ScenarioStatsRequest.SerializeToString,
            spm__pb2.ScenarioStats.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetModel(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, '/SPM/GetModel',
            spm__pb2.Model.SerializeToString,
            spm__pb2.Model.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DuplicateScenario(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, '/SPM/DuplicateScenario',
            spm__pb2.DuplicateScenarioRequest.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PushExecutionLogEntries(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, '/SPM/PushExecutionLogEntries',
            spm__pb2.LogEntries.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReadExecutionLogEntries(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, '/SPM/ReadExecutionLogEntries',
            spm__pb2.ExecutionReadLogs.SerializeToString,
            spm__pb2.ExeLogEntry.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetScenario(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, '/SPM/GetScenario',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.ScenarioDocument.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetScenarioResultDocument(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, '/SPM/SetScenarioResultDocument',
            spm__pb2.ScenarioResultsDocument.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetScenarioResultDocument(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, '/SPM/GetScenarioResultDocument',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.ScenarioResultsDocument.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetUser(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, '/SPM/GetUser',
            spm__pb2.UserRequest.SerializeToString,
            spm__pb2.User.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetGroup(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, '/SPM/GetGroup',
            spm__pb2.Group.SerializeToString,
            spm__pb2.GroupDocument.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProject(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, '/SPM/GetProject',
            spm__pb2.Project.SerializeToString,
            spm__pb2.ProjectDocument.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteScenario(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, '/SPM/DeleteScenario',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteProject(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, '/SPM/DeleteProject',
            spm__pb2.Project.SerializeToString,
            spm__pb2.Project.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteSystem(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, '/SPM/DeleteSystem',
            spm__pb2.SystemRequest.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteUser(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, '/SPM/DeleteUser',
            spm__pb2.UserRequest.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListenScenario(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, '/SPM/ListenScenario',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.ScenarioDocument.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetScenarioProgress(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, '/SPM/SetScenarioProgress',
            spm__pb2.ScenarioProgress.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetScenarioDataTags(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, '/SPM/SetScenarioDataTags',
            spm__pb2.ScenarioDataTags.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PushScenarioError(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, '/SPM/PushScenarioError',
            spm__pb2.ScenarioError.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PushScenarioFormattedError(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, '/SPM/PushScenarioFormattedError',
            spm__pb2.ScenarioFormattedError.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSignedURLs(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, '/SPM/GetSignedURLs',
            spm__pb2.FilePaths.SerializeToString,
            spm__pb2.FileSignedUrls.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetPublicLink(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, '/SPM/GetPublicLink',
            spm__pb2.Link.SerializeToString,
            spm__pb2.SignedUrl.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GenerateScenarioUploadSignedURL(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, '/SPM/GenerateScenarioUploadSignedURL',
            spm__pb2.ScenarioFilePath.SerializeToString,
            spm__pb2.ScenarioUploadURL.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ClearScenarioResults(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, '/SPM/ClearScenarioResults',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetScenarioResults(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, '/SPM/SetScenarioResults',
            spm__pb2.ScenarioResults.SerializeToString,
            spm__pb2.Scenario.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetScenarioResults(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, '/SPM/GetScenarioResults',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.ScenarioResults.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SubscribeForUpdates(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, '/SPM/SubscribeForUpdates',
            spm__pb2.Subscription.SerializeToString,
            spm__pb2.SubscriptionMessage.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PublishSubscriptionMessage(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, '/SPM/PublishSubscriptionMessage',
            spm__pb2.SubscriptionMessage.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CompleteExecution(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, '/SPM/CompleteExecution',
            spm__pb2.CompleteExecutionMessage.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CompleteExecutionIgnoreInstance(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, '/SPM/CompleteExecutionIgnoreInstance',
            spm__pb2.ExecutionMessage.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateExecution(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, '/SPM/UpdateExecution',
            spm__pb2.Json.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ClearExecutionMemory(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, '/SPM/ClearExecutionMemory',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RemoveExecutionData(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, '/SPM/RemoveExecutionData',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetLatestMainExecution(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, '/SPM/GetLatestMainExecution',
            spm__pb2.Scenario.SerializeToString,
            spm__pb2.ExecutionId.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateProbe(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, '/SPM/UpdateProbe',
            spm__pb2.ProbeInformation.SerializeToString,
            spm__pb2.ProbeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WriteDataStream(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, '/SPM/WriteDataStream',
            spm__pb2.WriteDataStreamRequest.SerializeToString,
            spm__pb2.WriteDataStreamResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReadDataStream(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, '/SPM/ReadDataStream',
            spm__pb2.ReadDataStreamRequest.SerializeToString,
            spm__pb2.ReadDataStreamResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDataStreamStats(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, '/SPM/GetDataStreamStats',
            spm__pb2.GetDataStreamStatsRequest.SerializeToString,
            spm__pb2.GetDataStreamStatsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.StartJob = channel.unary_unary(
                '/JobManager/StartJob',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.ExecutionId.FromString,
                )
        self.StartJobWithTime = channel.unary_unary(
                '/JobManager/StartJobWithTime',
                request_serializer=spm__pb2.JobTime.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )
        self.StartJobWithSchedule = channel.unary_unary(
                '/JobManager/StartJobWithSchedule',
                request_serializer=spm__pb2.JobSchedule.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )
        self.StartJobWithTimeAndSchedule = channel.unary_unary(
                '/JobManager/StartJobWithTimeAndSchedule',
                request_serializer=spm__pb2.JobTimeSchedule.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )
        self.StartLocalJob = channel.unary_unary(
                '/JobManager/StartLocalJob',
                request_serializer=spm__pb2.StartLocalJobRequest.SerializeToString,
                response_deserializer=spm__pb2.StartLocalJobResponse.FromString,
                )
        self.TerminateJob = channel.unary_unary(
                '/JobManager/TerminateJob',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )
        self.ResetJob = channel.unary_unary(
                '/JobManager/ResetJob',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )
        self.GetExecutionStatus = channel.unary_unary(
                '/JobManager/GetExecutionStatus',
                request_serializer=spm__pb2.ExecutionId.SerializeToString,
                response_deserializer=spm__pb2.Json.FromString,
                )
        self.GetExecutionState = channel.unary_unary(
                '/JobManager/GetExecutionState',
                request_serializer=spm__pb2.ExecutionStateMessage.SerializeToString,
                response_deserializer=spm__pb2.ExecutionState.FromString,
                )
        self.DeleteExecution = channel.unary_unary(
                '/JobManager/DeleteExecution',
                request_serializer=spm__pb2.ExecutionId.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.AddJobSchedule = channel.unary_unary(
                '/JobManager/AddJobSchedule',
                request_serializer=spm__pb2.JobSchedule.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.UpdateJobSchedule = channel.unary_unary(
                '/JobManager/UpdateJobSchedule',
                request_serializer=spm__pb2.JobSchedule.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.RemoveJobSchedule = channel.unary_unary(
                '/JobManager/RemoveJobSchedule',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.GetJobSchedule = channel.unary_unary(
                '/JobManager/GetJobSchedule',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.Schedule.FromString,
                )
        self.AddExecutionSchedule = channel.unary_unary(
                '/JobManager/AddExecutionSchedule',
                request_serializer=spm__pb2.ExecutionAndSchedule.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.UpdateExecutionSchedule = channel.unary_unary(
                '/JobManager/UpdateExecutionSchedule',
                request_serializer=spm__pb2.ExecutionAndSchedule.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.RemoveExecutionSchedule = channel.unary_unary(
                '/JobManager/RemoveExecutionSchedule',
                request_serializer=spm__pb2.ExecutionId.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.GetExecutionSchedule = channel.unary_unary(
                '/JobManager/GetExecutionSchedule',
                request_serializer=spm__pb2.ExecutionId.SerializeToString,
                response_deserializer=spm__pb2.Schedule.FromString,
                )
        self.ResumeJob = channel.unary_unary(
                '/JobManager/ResumeJob',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )
        self.HibernateJob = channel.unary_unary(
                '/JobManager/HibernateJob',
                request_serializer=spm__pb2.Job.SerializeToString,
                response_deserializer=spm__pb2.Job.FromString,
                )


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

    def StartJob(self, request, context):
        """Start Job endpoints
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartJobWithTime(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 StartJobWithSchedule(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 StartJobWithTimeAndSchedule(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 StartLocalJob(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 TerminateJob(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 ResetJob(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 GetExecutionStatus(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 GetExecutionState(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 DeleteExecution(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 AddJobSchedule(self, request, context):
        """Job scheduling
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateJobSchedule(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 RemoveJobSchedule(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 GetJobSchedule(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 AddExecutionSchedule(self, request, context):
        """Execution scheduling
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateExecutionSchedule(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 RemoveExecutionSchedule(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 GetExecutionSchedule(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 ResumeJob(self, request, context):
        """Hibernation
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HibernateJob(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_JobManagerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'StartJob': grpc.unary_unary_rpc_method_handler(
                    servicer.StartJob,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.ExecutionId.SerializeToString,
            ),
            'StartJobWithTime': grpc.unary_unary_rpc_method_handler(
                    servicer.StartJobWithTime,
                    request_deserializer=spm__pb2.JobTime.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
            'StartJobWithSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.StartJobWithSchedule,
                    request_deserializer=spm__pb2.JobSchedule.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
            'StartJobWithTimeAndSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.StartJobWithTimeAndSchedule,
                    request_deserializer=spm__pb2.JobTimeSchedule.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
            'StartLocalJob': grpc.unary_unary_rpc_method_handler(
                    servicer.StartLocalJob,
                    request_deserializer=spm__pb2.StartLocalJobRequest.FromString,
                    response_serializer=spm__pb2.StartLocalJobResponse.SerializeToString,
            ),
            'TerminateJob': grpc.unary_unary_rpc_method_handler(
                    servicer.TerminateJob,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
            'ResetJob': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetJob,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
            'GetExecutionStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExecutionStatus,
                    request_deserializer=spm__pb2.ExecutionId.FromString,
                    response_serializer=spm__pb2.Json.SerializeToString,
            ),
            'GetExecutionState': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExecutionState,
                    request_deserializer=spm__pb2.ExecutionStateMessage.FromString,
                    response_serializer=spm__pb2.ExecutionState.SerializeToString,
            ),
            'DeleteExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteExecution,
                    request_deserializer=spm__pb2.ExecutionId.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'AddJobSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.AddJobSchedule,
                    request_deserializer=spm__pb2.JobSchedule.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'UpdateJobSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateJobSchedule,
                    request_deserializer=spm__pb2.JobSchedule.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'RemoveJobSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveJobSchedule,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'GetJobSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.GetJobSchedule,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.Schedule.SerializeToString,
            ),
            'AddExecutionSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.AddExecutionSchedule,
                    request_deserializer=spm__pb2.ExecutionAndSchedule.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'UpdateExecutionSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateExecutionSchedule,
                    request_deserializer=spm__pb2.ExecutionAndSchedule.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'RemoveExecutionSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveExecutionSchedule,
                    request_deserializer=spm__pb2.ExecutionId.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'GetExecutionSchedule': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExecutionSchedule,
                    request_deserializer=spm__pb2.ExecutionId.FromString,
                    response_serializer=spm__pb2.Schedule.SerializeToString,
            ),
            'ResumeJob': grpc.unary_unary_rpc_method_handler(
                    servicer.ResumeJob,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
            'HibernateJob': grpc.unary_unary_rpc_method_handler(
                    servicer.HibernateJob,
                    request_deserializer=spm__pb2.Job.FromString,
                    response_serializer=spm__pb2.Job.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'JobManager', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def StartJob(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, '/JobManager/StartJob',
            spm__pb2.Job.SerializeToString,
            spm__pb2.ExecutionId.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartJobWithTime(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, '/JobManager/StartJobWithTime',
            spm__pb2.JobTime.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartJobWithSchedule(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, '/JobManager/StartJobWithSchedule',
            spm__pb2.JobSchedule.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartJobWithTimeAndSchedule(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, '/JobManager/StartJobWithTimeAndSchedule',
            spm__pb2.JobTimeSchedule.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartLocalJob(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, '/JobManager/StartLocalJob',
            spm__pb2.StartLocalJobRequest.SerializeToString,
            spm__pb2.StartLocalJobResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TerminateJob(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, '/JobManager/TerminateJob',
            spm__pb2.Job.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ResetJob(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, '/JobManager/ResetJob',
            spm__pb2.Job.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetExecutionStatus(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, '/JobManager/GetExecutionStatus',
            spm__pb2.ExecutionId.SerializeToString,
            spm__pb2.Json.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetExecutionState(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, '/JobManager/GetExecutionState',
            spm__pb2.ExecutionStateMessage.SerializeToString,
            spm__pb2.ExecutionState.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteExecution(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, '/JobManager/DeleteExecution',
            spm__pb2.ExecutionId.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AddJobSchedule(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, '/JobManager/AddJobSchedule',
            spm__pb2.JobSchedule.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateJobSchedule(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, '/JobManager/UpdateJobSchedule',
            spm__pb2.JobSchedule.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RemoveJobSchedule(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, '/JobManager/RemoveJobSchedule',
            spm__pb2.Job.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetJobSchedule(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, '/JobManager/GetJobSchedule',
            spm__pb2.Job.SerializeToString,
            spm__pb2.Schedule.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AddExecutionSchedule(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, '/JobManager/AddExecutionSchedule',
            spm__pb2.ExecutionAndSchedule.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateExecutionSchedule(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, '/JobManager/UpdateExecutionSchedule',
            spm__pb2.ExecutionAndSchedule.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RemoveExecutionSchedule(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, '/JobManager/RemoveExecutionSchedule',
            spm__pb2.ExecutionId.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetExecutionSchedule(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, '/JobManager/GetExecutionSchedule',
            spm__pb2.ExecutionId.SerializeToString,
            spm__pb2.Schedule.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ResumeJob(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, '/JobManager/ResumeJob',
            spm__pb2.Job.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def HibernateJob(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, '/JobManager/HibernateJob',
            spm__pb2.Job.SerializeToString,
            spm__pb2.Job.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.AuthenticateUser = channel.unary_unary(
                '/TokenManager/AuthenticateUser',
                request_serializer=spm__pb2.AuthenticateUserRequest.SerializeToString,
                response_deserializer=spm__pb2.AuthenticateUserResponse.FromString,
                )
        self.RefreshUser = channel.unary_unary(
                '/TokenManager/RefreshUser',
                request_serializer=spm__pb2.RefreshUserRequest.SerializeToString,
                response_deserializer=spm__pb2.RefreshUserResponse.FromString,
                )
        self.CreateRefreshToken = channel.unary_unary(
                '/TokenManager/CreateRefreshToken',
                request_serializer=spm__pb2.TokenRequest.SerializeToString,
                response_deserializer=spm__pb2.Token.FromString,
                )
        self.GetAccessToken = channel.unary_unary(
                '/TokenManager/GetAccessToken',
                request_serializer=spm__pb2.RefreshRequest.SerializeToString,
                response_deserializer=spm__pb2.Token.FromString,
                )


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

    def AuthenticateUser(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 RefreshUser(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 CreateRefreshToken(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 GetAccessToken(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_TokenManagerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AuthenticateUser': grpc.unary_unary_rpc_method_handler(
                    servicer.AuthenticateUser,
                    request_deserializer=spm__pb2.AuthenticateUserRequest.FromString,
                    response_serializer=spm__pb2.AuthenticateUserResponse.SerializeToString,
            ),
            'RefreshUser': grpc.unary_unary_rpc_method_handler(
                    servicer.RefreshUser,
                    request_deserializer=spm__pb2.RefreshUserRequest.FromString,
                    response_serializer=spm__pb2.RefreshUserResponse.SerializeToString,
            ),
            'CreateRefreshToken': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateRefreshToken,
                    request_deserializer=spm__pb2.TokenRequest.FromString,
                    response_serializer=spm__pb2.Token.SerializeToString,
            ),
            'GetAccessToken': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAccessToken,
                    request_deserializer=spm__pb2.RefreshRequest.FromString,
                    response_serializer=spm__pb2.Token.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'TokenManager', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def AuthenticateUser(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, '/TokenManager/AuthenticateUser',
            spm__pb2.AuthenticateUserRequest.SerializeToString,
            spm__pb2.AuthenticateUserResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RefreshUser(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, '/TokenManager/RefreshUser',
            spm__pb2.RefreshUserRequest.SerializeToString,
            spm__pb2.RefreshUserResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateRefreshToken(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, '/TokenManager/CreateRefreshToken',
            spm__pb2.TokenRequest.SerializeToString,
            spm__pb2.Token.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetAccessToken(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, '/TokenManager/GetAccessToken',
            spm__pb2.RefreshRequest.SerializeToString,
            spm__pb2.Token.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateSnapshot = channel.unary_unary(
                '/BuildManager/CreateSnapshot',
                request_serializer=spm__pb2.Snapshot.SerializeToString,
                response_deserializer=spm__pb2.SnapshotReply.FromString,
                )
        self.CreateHistoryUpdate = channel.unary_unary(
                '/BuildManager/CreateHistoryUpdate',
                request_serializer=spm__pb2.HistoryUpdate.SerializeToString,
                response_deserializer=spm__pb2.HistoryReply.FromString,
                )
        self.GetHistory = channel.unary_unary(
                '/BuildManager/GetHistory',
                request_serializer=spm__pb2.HistoryRequest.SerializeToString,
                response_deserializer=spm__pb2.History.FromString,
                )
        self.PullSnapshot = channel.unary_unary(
                '/BuildManager/PullSnapshot',
                request_serializer=spm__pb2.PullRequest.SerializeToString,
                response_deserializer=spm__pb2.PullResponse.FromString,
                )
        self.LaunchBuild = channel.unary_unary(
                '/BuildManager/LaunchBuild',
                request_serializer=spm__pb2.BuildRequest.SerializeToString,
                response_deserializer=spm__pb2.BuildReply.FromString,
                )
        self.Builder = channel.stream_stream(
                '/BuildManager/Builder',
                request_serializer=spm__pb2.BuildResponse.SerializeToString,
                response_deserializer=spm__pb2.Json.FromString,
                )
        self.GetBuildInfo = channel.unary_unary(
                '/BuildManager/GetBuildInfo',
                request_serializer=spm__pb2.BuildInfoRequest.SerializeToString,
                response_deserializer=spm__pb2.BuildInfo.FromString,
                )
        self.UpdateBuild = channel.unary_unary(
                '/BuildManager/UpdateBuild',
                request_serializer=spm__pb2.BuildUpdate.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )
        self.UpdateJobImageReference = channel.unary_unary(
                '/BuildManager/UpdateJobImageReference',
                request_serializer=spm__pb2.JobImageReferenceUpdate.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )


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

    def CreateSnapshot(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 CreateHistoryUpdate(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 GetHistory(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 PullSnapshot(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 LaunchBuild(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 Builder(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 GetBuildInfo(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 UpdateBuild(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 UpdateJobImageReference(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_BuildManagerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSnapshot,
                    request_deserializer=spm__pb2.Snapshot.FromString,
                    response_serializer=spm__pb2.SnapshotReply.SerializeToString,
            ),
            'CreateHistoryUpdate': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateHistoryUpdate,
                    request_deserializer=spm__pb2.HistoryUpdate.FromString,
                    response_serializer=spm__pb2.HistoryReply.SerializeToString,
            ),
            'GetHistory': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHistory,
                    request_deserializer=spm__pb2.HistoryRequest.FromString,
                    response_serializer=spm__pb2.History.SerializeToString,
            ),
            'PullSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.PullSnapshot,
                    request_deserializer=spm__pb2.PullRequest.FromString,
                    response_serializer=spm__pb2.PullResponse.SerializeToString,
            ),
            'LaunchBuild': grpc.unary_unary_rpc_method_handler(
                    servicer.LaunchBuild,
                    request_deserializer=spm__pb2.BuildRequest.FromString,
                    response_serializer=spm__pb2.BuildReply.SerializeToString,
            ),
            'Builder': grpc.stream_stream_rpc_method_handler(
                    servicer.Builder,
                    request_deserializer=spm__pb2.BuildResponse.FromString,
                    response_serializer=spm__pb2.Json.SerializeToString,
            ),
            'GetBuildInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBuildInfo,
                    request_deserializer=spm__pb2.BuildInfoRequest.FromString,
                    response_serializer=spm__pb2.BuildInfo.SerializeToString,
            ),
            'UpdateBuild': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateBuild,
                    request_deserializer=spm__pb2.BuildUpdate.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
            'UpdateJobImageReference': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateJobImageReference,
                    request_deserializer=spm__pb2.JobImageReferenceUpdate.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'BuildManager', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def CreateSnapshot(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, '/BuildManager/CreateSnapshot',
            spm__pb2.Snapshot.SerializeToString,
            spm__pb2.SnapshotReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateHistoryUpdate(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, '/BuildManager/CreateHistoryUpdate',
            spm__pb2.HistoryUpdate.SerializeToString,
            spm__pb2.HistoryReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetHistory(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, '/BuildManager/GetHistory',
            spm__pb2.HistoryRequest.SerializeToString,
            spm__pb2.History.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PullSnapshot(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, '/BuildManager/PullSnapshot',
            spm__pb2.PullRequest.SerializeToString,
            spm__pb2.PullResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LaunchBuild(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, '/BuildManager/LaunchBuild',
            spm__pb2.BuildRequest.SerializeToString,
            spm__pb2.BuildReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Builder(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, '/BuildManager/Builder',
            spm__pb2.BuildResponse.SerializeToString,
            spm__pb2.Json.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetBuildInfo(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, '/BuildManager/GetBuildInfo',
            spm__pb2.BuildInfoRequest.SerializeToString,
            spm__pb2.BuildInfo.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateBuild(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, '/BuildManager/UpdateBuild',
            spm__pb2.BuildUpdate.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateJobImageReference(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, '/BuildManager/UpdateJobImageReference',
            spm__pb2.JobImageReferenceUpdate.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetDownloadUrls = channel.unary_unary(
                '/FileManager/GetDownloadUrls',
                request_serializer=spm__pb2.FilePaths.SerializeToString,
                response_deserializer=spm__pb2.FileUrls.FromString,
                )
        self.GetUploadUrls = channel.unary_unary(
                '/FileManager/GetUploadUrls',
                request_serializer=spm__pb2.FilePaths.SerializeToString,
                response_deserializer=spm__pb2.FileUrls.FromString,
                )
        self.DeleteFiles = channel.unary_unary(
                '/FileManager/DeleteFiles',
                request_serializer=spm__pb2.FilePaths.SerializeToString,
                response_deserializer=spm__pb2.Empty.FromString,
                )


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

    def GetDownloadUrls(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 GetUploadUrls(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 DeleteFiles(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_FileManagerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetDownloadUrls': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDownloadUrls,
                    request_deserializer=spm__pb2.FilePaths.FromString,
                    response_serializer=spm__pb2.FileUrls.SerializeToString,
            ),
            'GetUploadUrls': grpc.unary_unary_rpc_method_handler(
                    servicer.GetUploadUrls,
                    request_deserializer=spm__pb2.FilePaths.FromString,
                    response_serializer=spm__pb2.FileUrls.SerializeToString,
            ),
            'DeleteFiles': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteFiles,
                    request_deserializer=spm__pb2.FilePaths.FromString,
                    response_serializer=spm__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'FileManager', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def GetDownloadUrls(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, '/FileManager/GetDownloadUrls',
            spm__pb2.FilePaths.SerializeToString,
            spm__pb2.FileUrls.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetUploadUrls(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, '/FileManager/GetUploadUrls',
            spm__pb2.FilePaths.SerializeToString,
            spm__pb2.FileUrls.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteFiles(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, '/FileManager/DeleteFiles',
            spm__pb2.FilePaths.SerializeToString,
            spm__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
