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

from . import job_pb2 as job__pb2


class FrameInterfaceStub(object):
    """Job related messages and services
    This includes Job, Layer, Frame, and Group objects

    -------- Services --------]

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.AddRenderPartition = channel.unary_unary(
                '/job.FrameInterface/AddRenderPartition',
                request_serializer=job__pb2.FrameAddRenderPartitionRequest.SerializeToString,
                response_deserializer=job__pb2.FrameAddRenderPartitionResponse.FromString,
                )
        self.CreateDependencyOnFrame = channel.unary_unary(
                '/job.FrameInterface/CreateDependencyOnFrame',
                request_serializer=job__pb2.FrameCreateDependencyOnFrameRequest.SerializeToString,
                response_deserializer=job__pb2.FrameCreateDependencyOnFrameResponse.FromString,
                )
        self.CreateDependencyOnJob = channel.unary_unary(
                '/job.FrameInterface/CreateDependencyOnJob',
                request_serializer=job__pb2.FrameCreateDependencyOnJobRequest.SerializeToString,
                response_deserializer=job__pb2.FrameCreateDependencyOnJobResponse.FromString,
                )
        self.CreateDependencyOnLayer = channel.unary_unary(
                '/job.FrameInterface/CreateDependencyOnLayer',
                request_serializer=job__pb2.FrameCreateDependencyOnLayerRequest.SerializeToString,
                response_deserializer=job__pb2.FrameCreateDependencyOnLayerResponse.FromString,
                )
        self.DropDepends = channel.unary_unary(
                '/job.FrameInterface/DropDepends',
                request_serializer=job__pb2.FrameDropDependsRequest.SerializeToString,
                response_deserializer=job__pb2.FrameDropDependsResponse.FromString,
                )
        self.Eat = channel.unary_unary(
                '/job.FrameInterface/Eat',
                request_serializer=job__pb2.FrameEatRequest.SerializeToString,
                response_deserializer=job__pb2.FrameEatResponse.FromString,
                )
        self.FindFrame = channel.unary_unary(
                '/job.FrameInterface/FindFrame',
                request_serializer=job__pb2.FrameFindFrameRequest.SerializeToString,
                response_deserializer=job__pb2.FrameFindFrameResponse.FromString,
                )
        self.GetFrame = channel.unary_unary(
                '/job.FrameInterface/GetFrame',
                request_serializer=job__pb2.FrameGetFrameRequest.SerializeToString,
                response_deserializer=job__pb2.FrameGetFrameResponse.FromString,
                )
        self.GetFrames = channel.unary_unary(
                '/job.FrameInterface/GetFrames',
                request_serializer=job__pb2.FrameGetFramesRequest.SerializeToString,
                response_deserializer=job__pb2.FrameGetFramesResponse.FromString,
                )
        self.GetWhatDependsOnThis = channel.unary_unary(
                '/job.FrameInterface/GetWhatDependsOnThis',
                request_serializer=job__pb2.FrameGetWhatDependsOnThisRequest.SerializeToString,
                response_deserializer=job__pb2.FrameGetWhatDependsOnThisResponse.FromString,
                )
        self.GetWhatThisDependsOn = channel.unary_unary(
                '/job.FrameInterface/GetWhatThisDependsOn',
                request_serializer=job__pb2.FrameGetWhatThisDependsOnRequest.SerializeToString,
                response_deserializer=job__pb2.FrameGetWhatThisDependsOnResponse.FromString,
                )
        self.Kill = channel.unary_unary(
                '/job.FrameInterface/Kill',
                request_serializer=job__pb2.FrameKillRequest.SerializeToString,
                response_deserializer=job__pb2.FrameKillResponse.FromString,
                )
        self.MarkAsDepend = channel.unary_unary(
                '/job.FrameInterface/MarkAsDepend',
                request_serializer=job__pb2.FrameMarkAsDependRequest.SerializeToString,
                response_deserializer=job__pb2.FrameMarkAsDependResponse.FromString,
                )
        self.MarkAsWaiting = channel.unary_unary(
                '/job.FrameInterface/MarkAsWaiting',
                request_serializer=job__pb2.FrameMarkAsWaitingRequest.SerializeToString,
                response_deserializer=job__pb2.FrameMarkAsWaitingResponse.FromString,
                )
        self.Retry = channel.unary_unary(
                '/job.FrameInterface/Retry',
                request_serializer=job__pb2.FrameRetryRequest.SerializeToString,
                response_deserializer=job__pb2.FrameRetryResponse.FromString,
                )
        self.SetCheckpointState = channel.unary_unary(
                '/job.FrameInterface/SetCheckpointState',
                request_serializer=job__pb2.FrameSetCheckpointStateRequest.SerializeToString,
                response_deserializer=job__pb2.FrameSetCheckpointStateResponse.FromString,
                )
        self.SetFrameStateDisplayOverride = channel.unary_unary(
                '/job.FrameInterface/SetFrameStateDisplayOverride',
                request_serializer=job__pb2.FrameStateDisplayOverrideRequest.SerializeToString,
                response_deserializer=job__pb2.FrameStateDisplayOverrideResponse.FromString,
                )
        self.GetFrameStateDisplayOverrides = channel.unary_unary(
                '/job.FrameInterface/GetFrameStateDisplayOverrides',
                request_serializer=job__pb2.GetFrameStateDisplayOverridesRequest.SerializeToString,
                response_deserializer=job__pb2.GetFrameStateDisplayOverridesResponse.FromString,
                )


class FrameInterfaceServicer(object):
    """Job related messages and services
    This includes Job, Layer, Frame, and Group objects

    -------- Services --------]

    """

    def AddRenderPartition(self, request, context):
        """Add a render partition to the frame.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnFrame(self, request, context):
        """Sets up and returns a FrameOnFrame dependency.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnJob(self, request, context):
        """Sets up and returns a FrameOnJob dependency.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnLayer(self, request, context):
        """Sets up and returns a FrameOnLayer dependency.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropDepends(self, request, context):
        """Drops every dependendy that is causing this frame not to run.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Eat(self, request, context):
        """Eating a frame will stop rendering and will not try to coninue processing the frame.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindFrame(self, request, context):
        """Finds a frame in a pending job based on the job, layer, and frame number.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetFrame(self, request, context):
        """Get a frame from its unique id
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetFrames(self, request, context):
        """Get a frame from search criteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWhatDependsOnThis(self, request, context):
        """Returns a list of dependencies setup to depend on this frame.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWhatThisDependsOn(self, request, context):
        """Returns a list of dependencies that this frame depends on.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Kill(self, request, context):
        """Kills the frame if it is running
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarkAsDepend(self, request, context):
        """Will recount the number of active dependencies on the frame and put it back into the Depend state if that count
        is greater than 0.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarkAsWaiting(self, request, context):
        """Changes the frame's dependency count to 0, which will put the frame into the waiting state.  Retrying the frame
        will put it back into the waiting state.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Retry(self, request, context):
        """Retries the frame by setting it as waiting
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetCheckpointState(self, request, context):
        """Updates the state of the frame's checkpoint status.  If the checkpoint status is complete, then the frame's
        checkpointCoreSeconds is updated with the amount of render time that was checkpointed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetFrameStateDisplayOverride(self, request, context):
        """Set a frame's state display override
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetFrameStateDisplayOverrides(self, request, context):
        """Get a frame's state display overrides
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_FrameInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AddRenderPartition': grpc.unary_unary_rpc_method_handler(
                    servicer.AddRenderPartition,
                    request_deserializer=job__pb2.FrameAddRenderPartitionRequest.FromString,
                    response_serializer=job__pb2.FrameAddRenderPartitionResponse.SerializeToString,
            ),
            'CreateDependencyOnFrame': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnFrame,
                    request_deserializer=job__pb2.FrameCreateDependencyOnFrameRequest.FromString,
                    response_serializer=job__pb2.FrameCreateDependencyOnFrameResponse.SerializeToString,
            ),
            'CreateDependencyOnJob': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnJob,
                    request_deserializer=job__pb2.FrameCreateDependencyOnJobRequest.FromString,
                    response_serializer=job__pb2.FrameCreateDependencyOnJobResponse.SerializeToString,
            ),
            'CreateDependencyOnLayer': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnLayer,
                    request_deserializer=job__pb2.FrameCreateDependencyOnLayerRequest.FromString,
                    response_serializer=job__pb2.FrameCreateDependencyOnLayerResponse.SerializeToString,
            ),
            'DropDepends': grpc.unary_unary_rpc_method_handler(
                    servicer.DropDepends,
                    request_deserializer=job__pb2.FrameDropDependsRequest.FromString,
                    response_serializer=job__pb2.FrameDropDependsResponse.SerializeToString,
            ),
            'Eat': grpc.unary_unary_rpc_method_handler(
                    servicer.Eat,
                    request_deserializer=job__pb2.FrameEatRequest.FromString,
                    response_serializer=job__pb2.FrameEatResponse.SerializeToString,
            ),
            'FindFrame': grpc.unary_unary_rpc_method_handler(
                    servicer.FindFrame,
                    request_deserializer=job__pb2.FrameFindFrameRequest.FromString,
                    response_serializer=job__pb2.FrameFindFrameResponse.SerializeToString,
            ),
            'GetFrame': grpc.unary_unary_rpc_method_handler(
                    servicer.GetFrame,
                    request_deserializer=job__pb2.FrameGetFrameRequest.FromString,
                    response_serializer=job__pb2.FrameGetFrameResponse.SerializeToString,
            ),
            'GetFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.GetFrames,
                    request_deserializer=job__pb2.FrameGetFramesRequest.FromString,
                    response_serializer=job__pb2.FrameGetFramesResponse.SerializeToString,
            ),
            'GetWhatDependsOnThis': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWhatDependsOnThis,
                    request_deserializer=job__pb2.FrameGetWhatDependsOnThisRequest.FromString,
                    response_serializer=job__pb2.FrameGetWhatDependsOnThisResponse.SerializeToString,
            ),
            'GetWhatThisDependsOn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWhatThisDependsOn,
                    request_deserializer=job__pb2.FrameGetWhatThisDependsOnRequest.FromString,
                    response_serializer=job__pb2.FrameGetWhatThisDependsOnResponse.SerializeToString,
            ),
            'Kill': grpc.unary_unary_rpc_method_handler(
                    servicer.Kill,
                    request_deserializer=job__pb2.FrameKillRequest.FromString,
                    response_serializer=job__pb2.FrameKillResponse.SerializeToString,
            ),
            'MarkAsDepend': grpc.unary_unary_rpc_method_handler(
                    servicer.MarkAsDepend,
                    request_deserializer=job__pb2.FrameMarkAsDependRequest.FromString,
                    response_serializer=job__pb2.FrameMarkAsDependResponse.SerializeToString,
            ),
            'MarkAsWaiting': grpc.unary_unary_rpc_method_handler(
                    servicer.MarkAsWaiting,
                    request_deserializer=job__pb2.FrameMarkAsWaitingRequest.FromString,
                    response_serializer=job__pb2.FrameMarkAsWaitingResponse.SerializeToString,
            ),
            'Retry': grpc.unary_unary_rpc_method_handler(
                    servicer.Retry,
                    request_deserializer=job__pb2.FrameRetryRequest.FromString,
                    response_serializer=job__pb2.FrameRetryResponse.SerializeToString,
            ),
            'SetCheckpointState': grpc.unary_unary_rpc_method_handler(
                    servicer.SetCheckpointState,
                    request_deserializer=job__pb2.FrameSetCheckpointStateRequest.FromString,
                    response_serializer=job__pb2.FrameSetCheckpointStateResponse.SerializeToString,
            ),
            'SetFrameStateDisplayOverride': grpc.unary_unary_rpc_method_handler(
                    servicer.SetFrameStateDisplayOverride,
                    request_deserializer=job__pb2.FrameStateDisplayOverrideRequest.FromString,
                    response_serializer=job__pb2.FrameStateDisplayOverrideResponse.SerializeToString,
            ),
            'GetFrameStateDisplayOverrides': grpc.unary_unary_rpc_method_handler(
                    servicer.GetFrameStateDisplayOverrides,
                    request_deserializer=job__pb2.GetFrameStateDisplayOverridesRequest.FromString,
                    response_serializer=job__pb2.GetFrameStateDisplayOverridesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'job.FrameInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class FrameInterface(object):
    """Job related messages and services
    This includes Job, Layer, Frame, and Group objects

    -------- Services --------]

    """

    @staticmethod
    def AddRenderPartition(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, '/job.FrameInterface/AddRenderPartition',
            job__pb2.FrameAddRenderPartitionRequest.SerializeToString,
            job__pb2.FrameAddRenderPartitionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnFrame(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, '/job.FrameInterface/CreateDependencyOnFrame',
            job__pb2.FrameCreateDependencyOnFrameRequest.SerializeToString,
            job__pb2.FrameCreateDependencyOnFrameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnJob(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, '/job.FrameInterface/CreateDependencyOnJob',
            job__pb2.FrameCreateDependencyOnJobRequest.SerializeToString,
            job__pb2.FrameCreateDependencyOnJobResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnLayer(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, '/job.FrameInterface/CreateDependencyOnLayer',
            job__pb2.FrameCreateDependencyOnLayerRequest.SerializeToString,
            job__pb2.FrameCreateDependencyOnLayerResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DropDepends(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, '/job.FrameInterface/DropDepends',
            job__pb2.FrameDropDependsRequest.SerializeToString,
            job__pb2.FrameDropDependsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Eat(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, '/job.FrameInterface/Eat',
            job__pb2.FrameEatRequest.SerializeToString,
            job__pb2.FrameEatResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FindFrame(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, '/job.FrameInterface/FindFrame',
            job__pb2.FrameFindFrameRequest.SerializeToString,
            job__pb2.FrameFindFrameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetFrame(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, '/job.FrameInterface/GetFrame',
            job__pb2.FrameGetFrameRequest.SerializeToString,
            job__pb2.FrameGetFrameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetFrames(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, '/job.FrameInterface/GetFrames',
            job__pb2.FrameGetFramesRequest.SerializeToString,
            job__pb2.FrameGetFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWhatDependsOnThis(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, '/job.FrameInterface/GetWhatDependsOnThis',
            job__pb2.FrameGetWhatDependsOnThisRequest.SerializeToString,
            job__pb2.FrameGetWhatDependsOnThisResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWhatThisDependsOn(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, '/job.FrameInterface/GetWhatThisDependsOn',
            job__pb2.FrameGetWhatThisDependsOnRequest.SerializeToString,
            job__pb2.FrameGetWhatThisDependsOnResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Kill(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, '/job.FrameInterface/Kill',
            job__pb2.FrameKillRequest.SerializeToString,
            job__pb2.FrameKillResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarkAsDepend(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, '/job.FrameInterface/MarkAsDepend',
            job__pb2.FrameMarkAsDependRequest.SerializeToString,
            job__pb2.FrameMarkAsDependResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarkAsWaiting(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, '/job.FrameInterface/MarkAsWaiting',
            job__pb2.FrameMarkAsWaitingRequest.SerializeToString,
            job__pb2.FrameMarkAsWaitingResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Retry(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, '/job.FrameInterface/Retry',
            job__pb2.FrameRetryRequest.SerializeToString,
            job__pb2.FrameRetryResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetCheckpointState(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, '/job.FrameInterface/SetCheckpointState',
            job__pb2.FrameSetCheckpointStateRequest.SerializeToString,
            job__pb2.FrameSetCheckpointStateResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetFrameStateDisplayOverride(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, '/job.FrameInterface/SetFrameStateDisplayOverride',
            job__pb2.FrameStateDisplayOverrideRequest.SerializeToString,
            job__pb2.FrameStateDisplayOverrideResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetFrameStateDisplayOverrides(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, '/job.FrameInterface/GetFrameStateDisplayOverrides',
            job__pb2.GetFrameStateDisplayOverridesRequest.SerializeToString,
            job__pb2.GetFrameStateDisplayOverridesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateSubGroup = channel.unary_unary(
                '/job.GroupInterface/CreateSubGroup',
                request_serializer=job__pb2.GroupCreateSubGroupRequest.SerializeToString,
                response_deserializer=job__pb2.GroupCreateSubGroupResponse.FromString,
                )
        self.Delete = channel.unary_unary(
                '/job.GroupInterface/Delete',
                request_serializer=job__pb2.GroupDeleteRequest.SerializeToString,
                response_deserializer=job__pb2.GroupDeleteResponse.FromString,
                )
        self.FindGroup = channel.unary_unary(
                '/job.GroupInterface/FindGroup',
                request_serializer=job__pb2.GroupFindGroupRequest.SerializeToString,
                response_deserializer=job__pb2.GroupFindGroupResponse.FromString,
                )
        self.GetGroup = channel.unary_unary(
                '/job.GroupInterface/GetGroup',
                request_serializer=job__pb2.GroupGetGroupRequest.SerializeToString,
                response_deserializer=job__pb2.GroupGetGroupResponse.FromString,
                )
        self.GetGroups = channel.unary_unary(
                '/job.GroupInterface/GetGroups',
                request_serializer=job__pb2.GroupGetGroupsRequest.SerializeToString,
                response_deserializer=job__pb2.GroupGetGroupsResponse.FromString,
                )
        self.GetJobs = channel.unary_unary(
                '/job.GroupInterface/GetJobs',
                request_serializer=job__pb2.GroupGetJobsRequest.SerializeToString,
                response_deserializer=job__pb2.GroupGetJobsResponse.FromString,
                )
        self.ReparentGroups = channel.unary_unary(
                '/job.GroupInterface/ReparentGroups',
                request_serializer=job__pb2.GroupReparentGroupsRequest.SerializeToString,
                response_deserializer=job__pb2.GroupReparentGroupsResponse.FromString,
                )
        self.ReparentJobs = channel.unary_unary(
                '/job.GroupInterface/ReparentJobs',
                request_serializer=job__pb2.GroupReparentJobsRequest.SerializeToString,
                response_deserializer=job__pb2.GroupReparentJobsResponse.FromString,
                )
        self.SetDefaultJobMaxCores = channel.unary_unary(
                '/job.GroupInterface/SetDefaultJobMaxCores',
                request_serializer=job__pb2.GroupSetDefJobMaxCoresRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetDefJobMaxCoresResponse.FromString,
                )
        self.SetDefaultJobMinCores = channel.unary_unary(
                '/job.GroupInterface/SetDefaultJobMinCores',
                request_serializer=job__pb2.GroupSetDefJobMinCoresRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetDefJobMinCoresResponse.FromString,
                )
        self.SetDefaultJobMaxGpus = channel.unary_unary(
                '/job.GroupInterface/SetDefaultJobMaxGpus',
                request_serializer=job__pb2.GroupSetDefJobMaxGpusRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetDefJobMaxGpusResponse.FromString,
                )
        self.SetDefaultJobMinGpus = channel.unary_unary(
                '/job.GroupInterface/SetDefaultJobMinGpus',
                request_serializer=job__pb2.GroupSetDefJobMinGpusRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetDefJobMinGpusResponse.FromString,
                )
        self.SetDefaultJobPriority = channel.unary_unary(
                '/job.GroupInterface/SetDefaultJobPriority',
                request_serializer=job__pb2.GroupSetDefJobPriorityRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetDefJobPriorityResponse.FromString,
                )
        self.SetDepartment = channel.unary_unary(
                '/job.GroupInterface/SetDepartment',
                request_serializer=job__pb2.GroupSetDeptRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetDeptResponse.FromString,
                )
        self.SetGroup = channel.unary_unary(
                '/job.GroupInterface/SetGroup',
                request_serializer=job__pb2.GroupSetGroupRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetGroupResponse.FromString,
                )
        self.SetMaxCores = channel.unary_unary(
                '/job.GroupInterface/SetMaxCores',
                request_serializer=job__pb2.GroupSetMaxCoresRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetMaxCoresResponse.FromString,
                )
        self.SetMinCores = channel.unary_unary(
                '/job.GroupInterface/SetMinCores',
                request_serializer=job__pb2.GroupSetMinCoresRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetMinCoresResponse.FromString,
                )
        self.SetMaxGpus = channel.unary_unary(
                '/job.GroupInterface/SetMaxGpus',
                request_serializer=job__pb2.GroupSetMaxGpusRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetMaxGpusResponse.FromString,
                )
        self.SetMinGpus = channel.unary_unary(
                '/job.GroupInterface/SetMinGpus',
                request_serializer=job__pb2.GroupSetMinGpusRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetMinGpusResponse.FromString,
                )
        self.SetName = channel.unary_unary(
                '/job.GroupInterface/SetName',
                request_serializer=job__pb2.GroupSetNameRequest.SerializeToString,
                response_deserializer=job__pb2.GroupSetNameResponse.FromString,
                )


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

    def CreateSubGroup(self, request, context):
        """Create a new sub group of the given name
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """Delete the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindGroup(self, request, context):
        """Finds a group by show name and group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetGroup(self, request, context):
        """Gets a group by its id
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetGroups(self, request, context):
        """Get child groups of the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetJobs(self, request, context):
        """Get Jobs of the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReparentGroups(self, request, context):
        """Reparent the provided groups to the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReparentJobs(self, request, context):
        """Reparent the provided jobs to the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDefaultJobMaxCores(self, request, context):
        """Set the Default Job Max Core values to all in the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDefaultJobMinCores(self, request, context):
        """Set the Default Job Min Core values to all in the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDefaultJobMaxGpus(self, request, context):
        """Set the Default Job Max Gpu values to all in the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDefaultJobMinGpus(self, request, context):
        """Set the Default Job Min Gpu values to all in the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDefaultJobPriority(self, request, context):
        """Set the Default Job Priority values to all in the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDepartment(self, request, context):
        """Set the department associated with the provided group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetGroup(self, request, context):
        """Set the provided groups parent group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxCores(self, request, context):
        """Set the group's Max Cores value
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinCores(self, request, context):
        """Set the groups Min Cores values
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxGpus(self, request, context):
        """Set the group's Max Gpu value
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinGpus(self, request, context):
        """Set the groups Min Gpu values
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetName(self, request, context):
        """Set the groups name
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_GroupInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateSubGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSubGroup,
                    request_deserializer=job__pb2.GroupCreateSubGroupRequest.FromString,
                    response_serializer=job__pb2.GroupCreateSubGroupResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=job__pb2.GroupDeleteRequest.FromString,
                    response_serializer=job__pb2.GroupDeleteResponse.SerializeToString,
            ),
            'FindGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.FindGroup,
                    request_deserializer=job__pb2.GroupFindGroupRequest.FromString,
                    response_serializer=job__pb2.GroupFindGroupResponse.SerializeToString,
            ),
            'GetGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.GetGroup,
                    request_deserializer=job__pb2.GroupGetGroupRequest.FromString,
                    response_serializer=job__pb2.GroupGetGroupResponse.SerializeToString,
            ),
            'GetGroups': grpc.unary_unary_rpc_method_handler(
                    servicer.GetGroups,
                    request_deserializer=job__pb2.GroupGetGroupsRequest.FromString,
                    response_serializer=job__pb2.GroupGetGroupsResponse.SerializeToString,
            ),
            'GetJobs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetJobs,
                    request_deserializer=job__pb2.GroupGetJobsRequest.FromString,
                    response_serializer=job__pb2.GroupGetJobsResponse.SerializeToString,
            ),
            'ReparentGroups': grpc.unary_unary_rpc_method_handler(
                    servicer.ReparentGroups,
                    request_deserializer=job__pb2.GroupReparentGroupsRequest.FromString,
                    response_serializer=job__pb2.GroupReparentGroupsResponse.SerializeToString,
            ),
            'ReparentJobs': grpc.unary_unary_rpc_method_handler(
                    servicer.ReparentJobs,
                    request_deserializer=job__pb2.GroupReparentJobsRequest.FromString,
                    response_serializer=job__pb2.GroupReparentJobsResponse.SerializeToString,
            ),
            'SetDefaultJobMaxCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDefaultJobMaxCores,
                    request_deserializer=job__pb2.GroupSetDefJobMaxCoresRequest.FromString,
                    response_serializer=job__pb2.GroupSetDefJobMaxCoresResponse.SerializeToString,
            ),
            'SetDefaultJobMinCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDefaultJobMinCores,
                    request_deserializer=job__pb2.GroupSetDefJobMinCoresRequest.FromString,
                    response_serializer=job__pb2.GroupSetDefJobMinCoresResponse.SerializeToString,
            ),
            'SetDefaultJobMaxGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDefaultJobMaxGpus,
                    request_deserializer=job__pb2.GroupSetDefJobMaxGpusRequest.FromString,
                    response_serializer=job__pb2.GroupSetDefJobMaxGpusResponse.SerializeToString,
            ),
            'SetDefaultJobMinGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDefaultJobMinGpus,
                    request_deserializer=job__pb2.GroupSetDefJobMinGpusRequest.FromString,
                    response_serializer=job__pb2.GroupSetDefJobMinGpusResponse.SerializeToString,
            ),
            'SetDefaultJobPriority': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDefaultJobPriority,
                    request_deserializer=job__pb2.GroupSetDefJobPriorityRequest.FromString,
                    response_serializer=job__pb2.GroupSetDefJobPriorityResponse.SerializeToString,
            ),
            'SetDepartment': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDepartment,
                    request_deserializer=job__pb2.GroupSetDeptRequest.FromString,
                    response_serializer=job__pb2.GroupSetDeptResponse.SerializeToString,
            ),
            'SetGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.SetGroup,
                    request_deserializer=job__pb2.GroupSetGroupRequest.FromString,
                    response_serializer=job__pb2.GroupSetGroupResponse.SerializeToString,
            ),
            'SetMaxCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxCores,
                    request_deserializer=job__pb2.GroupSetMaxCoresRequest.FromString,
                    response_serializer=job__pb2.GroupSetMaxCoresResponse.SerializeToString,
            ),
            'SetMinCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinCores,
                    request_deserializer=job__pb2.GroupSetMinCoresRequest.FromString,
                    response_serializer=job__pb2.GroupSetMinCoresResponse.SerializeToString,
            ),
            'SetMaxGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxGpus,
                    request_deserializer=job__pb2.GroupSetMaxGpusRequest.FromString,
                    response_serializer=job__pb2.GroupSetMaxGpusResponse.SerializeToString,
            ),
            'SetMinGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinGpus,
                    request_deserializer=job__pb2.GroupSetMinGpusRequest.FromString,
                    response_serializer=job__pb2.GroupSetMinGpusResponse.SerializeToString,
            ),
            'SetName': grpc.unary_unary_rpc_method_handler(
                    servicer.SetName,
                    request_deserializer=job__pb2.GroupSetNameRequest.FromString,
                    response_serializer=job__pb2.GroupSetNameResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'job.GroupInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def CreateSubGroup(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, '/job.GroupInterface/CreateSubGroup',
            job__pb2.GroupCreateSubGroupRequest.SerializeToString,
            job__pb2.GroupCreateSubGroupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Delete(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, '/job.GroupInterface/Delete',
            job__pb2.GroupDeleteRequest.SerializeToString,
            job__pb2.GroupDeleteResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FindGroup(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, '/job.GroupInterface/FindGroup',
            job__pb2.GroupFindGroupRequest.SerializeToString,
            job__pb2.GroupFindGroupResponse.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, '/job.GroupInterface/GetGroup',
            job__pb2.GroupGetGroupRequest.SerializeToString,
            job__pb2.GroupGetGroupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetGroups(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, '/job.GroupInterface/GetGroups',
            job__pb2.GroupGetGroupsRequest.SerializeToString,
            job__pb2.GroupGetGroupsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetJobs(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, '/job.GroupInterface/GetJobs',
            job__pb2.GroupGetJobsRequest.SerializeToString,
            job__pb2.GroupGetJobsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReparentGroups(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, '/job.GroupInterface/ReparentGroups',
            job__pb2.GroupReparentGroupsRequest.SerializeToString,
            job__pb2.GroupReparentGroupsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReparentJobs(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, '/job.GroupInterface/ReparentJobs',
            job__pb2.GroupReparentJobsRequest.SerializeToString,
            job__pb2.GroupReparentJobsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDefaultJobMaxCores(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, '/job.GroupInterface/SetDefaultJobMaxCores',
            job__pb2.GroupSetDefJobMaxCoresRequest.SerializeToString,
            job__pb2.GroupSetDefJobMaxCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDefaultJobMinCores(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, '/job.GroupInterface/SetDefaultJobMinCores',
            job__pb2.GroupSetDefJobMinCoresRequest.SerializeToString,
            job__pb2.GroupSetDefJobMinCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDefaultJobMaxGpus(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, '/job.GroupInterface/SetDefaultJobMaxGpus',
            job__pb2.GroupSetDefJobMaxGpusRequest.SerializeToString,
            job__pb2.GroupSetDefJobMaxGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDefaultJobMinGpus(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, '/job.GroupInterface/SetDefaultJobMinGpus',
            job__pb2.GroupSetDefJobMinGpusRequest.SerializeToString,
            job__pb2.GroupSetDefJobMinGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDefaultJobPriority(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, '/job.GroupInterface/SetDefaultJobPriority',
            job__pb2.GroupSetDefJobPriorityRequest.SerializeToString,
            job__pb2.GroupSetDefJobPriorityResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDepartment(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, '/job.GroupInterface/SetDepartment',
            job__pb2.GroupSetDeptRequest.SerializeToString,
            job__pb2.GroupSetDeptResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetGroup(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, '/job.GroupInterface/SetGroup',
            job__pb2.GroupSetGroupRequest.SerializeToString,
            job__pb2.GroupSetGroupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxCores(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, '/job.GroupInterface/SetMaxCores',
            job__pb2.GroupSetMaxCoresRequest.SerializeToString,
            job__pb2.GroupSetMaxCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinCores(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, '/job.GroupInterface/SetMinCores',
            job__pb2.GroupSetMinCoresRequest.SerializeToString,
            job__pb2.GroupSetMinCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxGpus(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, '/job.GroupInterface/SetMaxGpus',
            job__pb2.GroupSetMaxGpusRequest.SerializeToString,
            job__pb2.GroupSetMaxGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinGpus(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, '/job.GroupInterface/SetMinGpus',
            job__pb2.GroupSetMinGpusRequest.SerializeToString,
            job__pb2.GroupSetMinGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetName(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, '/job.GroupInterface/SetName',
            job__pb2.GroupSetNameRequest.SerializeToString,
            job__pb2.GroupSetNameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.AddComment = channel.unary_unary(
                '/job.JobInterface/AddComment',
                request_serializer=job__pb2.JobAddCommentRequest.SerializeToString,
                response_deserializer=job__pb2.JobAddCommentResponse.FromString,
                )
        self.AddRenderPartition = channel.unary_unary(
                '/job.JobInterface/AddRenderPartition',
                request_serializer=job__pb2.JobAddRenderPartRequest.SerializeToString,
                response_deserializer=job__pb2.JobAddRenderPartResponse.FromString,
                )
        self.AddSubscriber = channel.unary_unary(
                '/job.JobInterface/AddSubscriber',
                request_serializer=job__pb2.JobAddSubscriberRequest.SerializeToString,
                response_deserializer=job__pb2.JobAddSubscriberResponse.FromString,
                )
        self.CreateDependencyOnFrame = channel.unary_unary(
                '/job.JobInterface/CreateDependencyOnFrame',
                request_serializer=job__pb2.JobCreateDependencyOnFrameRequest.SerializeToString,
                response_deserializer=job__pb2.JobCreateDependencyOnFrameResponse.FromString,
                )
        self.CreateDependencyOnJob = channel.unary_unary(
                '/job.JobInterface/CreateDependencyOnJob',
                request_serializer=job__pb2.JobCreateDependencyOnJobRequest.SerializeToString,
                response_deserializer=job__pb2.JobCreateDependencyOnJobResponse.FromString,
                )
        self.CreateDependencyOnLayer = channel.unary_unary(
                '/job.JobInterface/CreateDependencyOnLayer',
                request_serializer=job__pb2.JobCreateDependencyOnLayerRequest.SerializeToString,
                response_deserializer=job__pb2.JobCreateDependencyOnLayerResponse.FromString,
                )
        self.DropDepends = channel.unary_unary(
                '/job.JobInterface/DropDepends',
                request_serializer=job__pb2.JobDropDependsRequest.SerializeToString,
                response_deserializer=job__pb2.JobDropDependsResponse.FromString,
                )
        self.EatFrames = channel.unary_unary(
                '/job.JobInterface/EatFrames',
                request_serializer=job__pb2.JobEatFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobEatFramesResponse.FromString,
                )
        self.FindJob = channel.unary_unary(
                '/job.JobInterface/FindJob',
                request_serializer=job__pb2.JobFindJobRequest.SerializeToString,
                response_deserializer=job__pb2.JobFindJobResponse.FromString,
                )
        self.GetComments = channel.unary_unary(
                '/job.JobInterface/GetComments',
                request_serializer=job__pb2.JobGetCommentsRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetCommentsResponse.FromString,
                )
        self.GetCurrent = channel.unary_unary(
                '/job.JobInterface/GetCurrent',
                request_serializer=job__pb2.JobGetCurrentRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetCurrentResponse.FromString,
                )
        self.GetDepends = channel.unary_unary(
                '/job.JobInterface/GetDepends',
                request_serializer=job__pb2.JobGetDependsRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetDependsResponse.FromString,
                )
        self.GetFrames = channel.unary_unary(
                '/job.JobInterface/GetFrames',
                request_serializer=job__pb2.JobGetFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetFramesResponse.FromString,
                )
        self.GetJob = channel.unary_unary(
                '/job.JobInterface/GetJob',
                request_serializer=job__pb2.JobGetJobRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetJobResponse.FromString,
                )
        self.GetJobs = channel.unary_unary(
                '/job.JobInterface/GetJobs',
                request_serializer=job__pb2.JobGetJobsRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetJobsResponse.FromString,
                )
        self.GetJobNames = channel.unary_unary(
                '/job.JobInterface/GetJobNames',
                request_serializer=job__pb2.JobGetJobNamesRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetJobNamesResponse.FromString,
                )
        self.GetLayers = channel.unary_unary(
                '/job.JobInterface/GetLayers',
                request_serializer=job__pb2.JobGetLayersRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetLayersResponse.FromString,
                )
        self.GetUpdatedFrames = channel.unary_unary(
                '/job.JobInterface/GetUpdatedFrames',
                request_serializer=job__pb2.JobGetUpdatedFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetUpdatedFramesResponse.FromString,
                )
        self.GetWhatDependsOnThis = channel.unary_unary(
                '/job.JobInterface/GetWhatDependsOnThis',
                request_serializer=job__pb2.JobGetWhatDependsOnThisRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetWhatDependsOnThisResponse.FromString,
                )
        self.GetWhatThisDependsOn = channel.unary_unary(
                '/job.JobInterface/GetWhatThisDependsOn',
                request_serializer=job__pb2.JobGetWhatThisDependsOnRequest.SerializeToString,
                response_deserializer=job__pb2.JobGetWhatThisDependsOnResponse.FromString,
                )
        self.IsJobPending = channel.unary_unary(
                '/job.JobInterface/IsJobPending',
                request_serializer=job__pb2.JobIsJobPendingRequest.SerializeToString,
                response_deserializer=job__pb2.JobIsJobPendingResponse.FromString,
                )
        self.Kill = channel.unary_unary(
                '/job.JobInterface/Kill',
                request_serializer=job__pb2.JobKillRequest.SerializeToString,
                response_deserializer=job__pb2.JobKillResponse.FromString,
                )
        self.KillFrames = channel.unary_unary(
                '/job.JobInterface/KillFrames',
                request_serializer=job__pb2.JobKillFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobKillFramesResponse.FromString,
                )
        self.LaunchSpecAndWait = channel.unary_unary(
                '/job.JobInterface/LaunchSpecAndWait',
                request_serializer=job__pb2.JobLaunchSpecAndWaitRequest.SerializeToString,
                response_deserializer=job__pb2.JobLaunchSpecAndWaitResponse.FromString,
                )
        self.LaunchSpec = channel.unary_unary(
                '/job.JobInterface/LaunchSpec',
                request_serializer=job__pb2.JobLaunchSpecRequest.SerializeToString,
                response_deserializer=job__pb2.JobLaunchSpecResponse.FromString,
                )
        self.MarkAsWaiting = channel.unary_unary(
                '/job.JobInterface/MarkAsWaiting',
                request_serializer=job__pb2.JobMarkAsWaitingRequest.SerializeToString,
                response_deserializer=job__pb2.JobMarkAsWaitingResponse.FromString,
                )
        self.MarkDoneFrames = channel.unary_unary(
                '/job.JobInterface/MarkDoneFrames',
                request_serializer=job__pb2.JobMarkDoneFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobMarkDoneFramesResponse.FromString,
                )
        self.Pause = channel.unary_unary(
                '/job.JobInterface/Pause',
                request_serializer=job__pb2.JobPauseRequest.SerializeToString,
                response_deserializer=job__pb2.JobPauseResponse.FromString,
                )
        self.ReorderFrames = channel.unary_unary(
                '/job.JobInterface/ReorderFrames',
                request_serializer=job__pb2.JobReorderFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobReorderFramesResponse.FromString,
                )
        self.Resume = channel.unary_unary(
                '/job.JobInterface/Resume',
                request_serializer=job__pb2.JobResumeRequest.SerializeToString,
                response_deserializer=job__pb2.JobResumeResponse.FromString,
                )
        self.RetryFrames = channel.unary_unary(
                '/job.JobInterface/RetryFrames',
                request_serializer=job__pb2.JobRetryFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobRetryFramesResponse.FromString,
                )
        self.RunFilters = channel.unary_unary(
                '/job.JobInterface/RunFilters',
                request_serializer=job__pb2.JobRunFiltersRequest.SerializeToString,
                response_deserializer=job__pb2.JobRunFiltersResponse.FromString,
                )
        self.SetAutoEat = channel.unary_unary(
                '/job.JobInterface/SetAutoEat',
                request_serializer=job__pb2.JobSetAutoEatRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetAutoEatResponse.FromString,
                )
        self.SetGroup = channel.unary_unary(
                '/job.JobInterface/SetGroup',
                request_serializer=job__pb2.JobSetGroupRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetGroupResponse.FromString,
                )
        self.SetMaxCores = channel.unary_unary(
                '/job.JobInterface/SetMaxCores',
                request_serializer=job__pb2.JobSetMaxCoresRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetMaxCoresResponse.FromString,
                )
        self.SetMaxRetries = channel.unary_unary(
                '/job.JobInterface/SetMaxRetries',
                request_serializer=job__pb2.JobSetMaxRetriesRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetMaxRetriesResponse.FromString,
                )
        self.SetMinCores = channel.unary_unary(
                '/job.JobInterface/SetMinCores',
                request_serializer=job__pb2.JobSetMinCoresRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetMinCoresResponse.FromString,
                )
        self.SetMaxGpus = channel.unary_unary(
                '/job.JobInterface/SetMaxGpus',
                request_serializer=job__pb2.JobSetMaxGpusRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetMaxGpusResponse.FromString,
                )
        self.SetMinGpus = channel.unary_unary(
                '/job.JobInterface/SetMinGpus',
                request_serializer=job__pb2.JobSetMinGpusRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetMinGpusResponse.FromString,
                )
        self.SetPriority = channel.unary_unary(
                '/job.JobInterface/SetPriority',
                request_serializer=job__pb2.JobSetPriorityRequest.SerializeToString,
                response_deserializer=job__pb2.JobSetPriorityResponse.FromString,
                )
        self.ShutdownIfCompleted = channel.unary_unary(
                '/job.JobInterface/ShutdownIfCompleted',
                request_serializer=job__pb2.JobShutdownIfCompletedRequest.SerializeToString,
                response_deserializer=job__pb2.JobShutdownIfCompletedResponse.FromString,
                )
        self.StaggerFrames = channel.unary_unary(
                '/job.JobInterface/StaggerFrames',
                request_serializer=job__pb2.JobStaggerFramesRequest.SerializeToString,
                response_deserializer=job__pb2.JobStaggerFramesResponse.FromString,
                )


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

    def AddComment(self, request, context):
        """Add a comment on this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddRenderPartition(self, request, context):
        """Add a render partition to the local host.  This partition will
        run frames on the specified job.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddSubscriber(self, request, context):
        """Adds a subscriber to a job. When the job is finished, subscriber
        receives email with notification
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnFrame(self, request, context):
        """Setup and retunrn a JobOnFrame dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnJob(self, request, context):
        """Setup and return a JobOnJob dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnLayer(self, request, context):
        """Setup and retunrn a JobOnLayer dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropDepends(self, request, context):
        """Drops all external dependencies for the job.  This means that
        the internal depend structure will be maintained, but everything
        that depends on another job will be dropped.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EatFrames(self, request, context):
        """Eats all frames that match the FrameSearchCriteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindJob(self, request, context):
        """Finds a pending job using the job name
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetComments(self, request, context):
        """Get the comments for this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCurrent(self, request, context):
        """Get the job details
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetDepends(self, request, context):
        """Returns a list of all dependencies that this job is involved with
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetFrames(self, request, context):
        """Returns all frame objects that match FrameSearchCriteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetJob(self, request, context):
        """Finds a pending job using the job name
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetJobs(self, request, context):
        """Returns a list of jobs based on specified criteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetJobNames(self, request, context):
        """Returns a sequence of job names using search criteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetLayers(self, request, context):
        """Returns all layer objects
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetUpdatedFrames(self, request, context):
        """Returns a UpdatedFrameCheckResult which contains
        updated state information for frames that have changed since the
        last update time as well as the current state of the job.

        If the user is filtering by layer, passing an array of layer
        proxies will limit the updates to specific layers.

        At most, your going to get 1 update per running frame every minute
        due to memory usage.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWhatDependsOnThis(self, request, context):
        """Returns a list of dependencies setup to depend on
        this job.  This includes all types of depends, not just
        OnJob dependencies.  This will not return any frame on frame
        dependencies that are part of a FrameByFrame depend.  It will
        return a single element that represents the entire dependency.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWhatThisDependsOn(self, request, context):
        """Returns a list of dependencies that this frame depends on.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def IsJobPending(self, request, context):
        """Returns true if the job is in the pending state the cue.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Kill(self, request, context):
        """Kill the job.  This puts the job into the Finished State
        All running frames are killed, all depends satisfied.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def KillFrames(self, request, context):
        """Kills all frames that match the FrameSearchCriteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LaunchSpecAndWait(self, request, context):
        """Launches a job spec and returns an array of launched jobs. Waits for jobs to be committed to DB.  This might time
        out before jobs are launched.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LaunchSpec(self, request, context):
        """Launches as a job spec and returns an array of job names that are being launched. This method returns immediately
        after basic checks. The job could fail to launch of a DB error occurs but that is rare.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarkAsWaiting(self, request, context):
        """Updates the matching frames from the Depend state to the waiting state
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarkDoneFrames(self, request, context):
        """Drops any dependency that requires any frame that matches the FrameSearchCriteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Pause(self, request, context):
        """Pauses the job, which means it no longer gets procs
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReorderFrames(self, request, context):
        """Reorders the specified frame range on this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Resume(self, request, context):
        """Resumes a paused job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RetryFrames(self, request, context):
        """Retries all frames that match the FrameSearchCriteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunFilters(self, request, context):
        """Rerun filters for this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetAutoEat(self, request, context):
        """If set to true, a frame that would have turned dead, will become eaten
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetGroup(self, request, context):
        """Move the job into the specified group
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxCores(self, request, context):
        """Sets the maximum number of procs that can run on this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxRetries(self, request, context):
        """Sets the default maximum number of frame retries for the job. One
        a frame has retried this many times it will automatically go
        to the dead state. The default upper limit on this is 16 retries.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinCores(self, request, context):
        """Sets the minimum number of procs that can run on this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxGpus(self, request, context):
        """Sets the maximum number of Gpu that can run on this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinGpus(self, request, context):
        """Sets the minimum number of Gpu that can run on this job
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetPriority(self, request, context):
        """Sets the job priority
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ShutdownIfCompleted(self, request, context):
        """Shutdown the job if it is completed. This is a workaround for when
        Cuebot failed to shutdown a job due to database access error.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StaggerFrames(self, request, context):
        """Staggers the specified frame range
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_JobInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AddComment': grpc.unary_unary_rpc_method_handler(
                    servicer.AddComment,
                    request_deserializer=job__pb2.JobAddCommentRequest.FromString,
                    response_serializer=job__pb2.JobAddCommentResponse.SerializeToString,
            ),
            'AddRenderPartition': grpc.unary_unary_rpc_method_handler(
                    servicer.AddRenderPartition,
                    request_deserializer=job__pb2.JobAddRenderPartRequest.FromString,
                    response_serializer=job__pb2.JobAddRenderPartResponse.SerializeToString,
            ),
            'AddSubscriber': grpc.unary_unary_rpc_method_handler(
                    servicer.AddSubscriber,
                    request_deserializer=job__pb2.JobAddSubscriberRequest.FromString,
                    response_serializer=job__pb2.JobAddSubscriberResponse.SerializeToString,
            ),
            'CreateDependencyOnFrame': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnFrame,
                    request_deserializer=job__pb2.JobCreateDependencyOnFrameRequest.FromString,
                    response_serializer=job__pb2.JobCreateDependencyOnFrameResponse.SerializeToString,
            ),
            'CreateDependencyOnJob': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnJob,
                    request_deserializer=job__pb2.JobCreateDependencyOnJobRequest.FromString,
                    response_serializer=job__pb2.JobCreateDependencyOnJobResponse.SerializeToString,
            ),
            'CreateDependencyOnLayer': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnLayer,
                    request_deserializer=job__pb2.JobCreateDependencyOnLayerRequest.FromString,
                    response_serializer=job__pb2.JobCreateDependencyOnLayerResponse.SerializeToString,
            ),
            'DropDepends': grpc.unary_unary_rpc_method_handler(
                    servicer.DropDepends,
                    request_deserializer=job__pb2.JobDropDependsRequest.FromString,
                    response_serializer=job__pb2.JobDropDependsResponse.SerializeToString,
            ),
            'EatFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.EatFrames,
                    request_deserializer=job__pb2.JobEatFramesRequest.FromString,
                    response_serializer=job__pb2.JobEatFramesResponse.SerializeToString,
            ),
            'FindJob': grpc.unary_unary_rpc_method_handler(
                    servicer.FindJob,
                    request_deserializer=job__pb2.JobFindJobRequest.FromString,
                    response_serializer=job__pb2.JobFindJobResponse.SerializeToString,
            ),
            'GetComments': grpc.unary_unary_rpc_method_handler(
                    servicer.GetComments,
                    request_deserializer=job__pb2.JobGetCommentsRequest.FromString,
                    response_serializer=job__pb2.JobGetCommentsResponse.SerializeToString,
            ),
            'GetCurrent': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCurrent,
                    request_deserializer=job__pb2.JobGetCurrentRequest.FromString,
                    response_serializer=job__pb2.JobGetCurrentResponse.SerializeToString,
            ),
            'GetDepends': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDepends,
                    request_deserializer=job__pb2.JobGetDependsRequest.FromString,
                    response_serializer=job__pb2.JobGetDependsResponse.SerializeToString,
            ),
            'GetFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.GetFrames,
                    request_deserializer=job__pb2.JobGetFramesRequest.FromString,
                    response_serializer=job__pb2.JobGetFramesResponse.SerializeToString,
            ),
            'GetJob': grpc.unary_unary_rpc_method_handler(
                    servicer.GetJob,
                    request_deserializer=job__pb2.JobGetJobRequest.FromString,
                    response_serializer=job__pb2.JobGetJobResponse.SerializeToString,
            ),
            'GetJobs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetJobs,
                    request_deserializer=job__pb2.JobGetJobsRequest.FromString,
                    response_serializer=job__pb2.JobGetJobsResponse.SerializeToString,
            ),
            'GetJobNames': grpc.unary_unary_rpc_method_handler(
                    servicer.GetJobNames,
                    request_deserializer=job__pb2.JobGetJobNamesRequest.FromString,
                    response_serializer=job__pb2.JobGetJobNamesResponse.SerializeToString,
            ),
            'GetLayers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLayers,
                    request_deserializer=job__pb2.JobGetLayersRequest.FromString,
                    response_serializer=job__pb2.JobGetLayersResponse.SerializeToString,
            ),
            'GetUpdatedFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.GetUpdatedFrames,
                    request_deserializer=job__pb2.JobGetUpdatedFramesRequest.FromString,
                    response_serializer=job__pb2.JobGetUpdatedFramesResponse.SerializeToString,
            ),
            'GetWhatDependsOnThis': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWhatDependsOnThis,
                    request_deserializer=job__pb2.JobGetWhatDependsOnThisRequest.FromString,
                    response_serializer=job__pb2.JobGetWhatDependsOnThisResponse.SerializeToString,
            ),
            'GetWhatThisDependsOn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWhatThisDependsOn,
                    request_deserializer=job__pb2.JobGetWhatThisDependsOnRequest.FromString,
                    response_serializer=job__pb2.JobGetWhatThisDependsOnResponse.SerializeToString,
            ),
            'IsJobPending': grpc.unary_unary_rpc_method_handler(
                    servicer.IsJobPending,
                    request_deserializer=job__pb2.JobIsJobPendingRequest.FromString,
                    response_serializer=job__pb2.JobIsJobPendingResponse.SerializeToString,
            ),
            'Kill': grpc.unary_unary_rpc_method_handler(
                    servicer.Kill,
                    request_deserializer=job__pb2.JobKillRequest.FromString,
                    response_serializer=job__pb2.JobKillResponse.SerializeToString,
            ),
            'KillFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.KillFrames,
                    request_deserializer=job__pb2.JobKillFramesRequest.FromString,
                    response_serializer=job__pb2.JobKillFramesResponse.SerializeToString,
            ),
            'LaunchSpecAndWait': grpc.unary_unary_rpc_method_handler(
                    servicer.LaunchSpecAndWait,
                    request_deserializer=job__pb2.JobLaunchSpecAndWaitRequest.FromString,
                    response_serializer=job__pb2.JobLaunchSpecAndWaitResponse.SerializeToString,
            ),
            'LaunchSpec': grpc.unary_unary_rpc_method_handler(
                    servicer.LaunchSpec,
                    request_deserializer=job__pb2.JobLaunchSpecRequest.FromString,
                    response_serializer=job__pb2.JobLaunchSpecResponse.SerializeToString,
            ),
            'MarkAsWaiting': grpc.unary_unary_rpc_method_handler(
                    servicer.MarkAsWaiting,
                    request_deserializer=job__pb2.JobMarkAsWaitingRequest.FromString,
                    response_serializer=job__pb2.JobMarkAsWaitingResponse.SerializeToString,
            ),
            'MarkDoneFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.MarkDoneFrames,
                    request_deserializer=job__pb2.JobMarkDoneFramesRequest.FromString,
                    response_serializer=job__pb2.JobMarkDoneFramesResponse.SerializeToString,
            ),
            'Pause': grpc.unary_unary_rpc_method_handler(
                    servicer.Pause,
                    request_deserializer=job__pb2.JobPauseRequest.FromString,
                    response_serializer=job__pb2.JobPauseResponse.SerializeToString,
            ),
            'ReorderFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.ReorderFrames,
                    request_deserializer=job__pb2.JobReorderFramesRequest.FromString,
                    response_serializer=job__pb2.JobReorderFramesResponse.SerializeToString,
            ),
            'Resume': grpc.unary_unary_rpc_method_handler(
                    servicer.Resume,
                    request_deserializer=job__pb2.JobResumeRequest.FromString,
                    response_serializer=job__pb2.JobResumeResponse.SerializeToString,
            ),
            'RetryFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.RetryFrames,
                    request_deserializer=job__pb2.JobRetryFramesRequest.FromString,
                    response_serializer=job__pb2.JobRetryFramesResponse.SerializeToString,
            ),
            'RunFilters': grpc.unary_unary_rpc_method_handler(
                    servicer.RunFilters,
                    request_deserializer=job__pb2.JobRunFiltersRequest.FromString,
                    response_serializer=job__pb2.JobRunFiltersResponse.SerializeToString,
            ),
            'SetAutoEat': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAutoEat,
                    request_deserializer=job__pb2.JobSetAutoEatRequest.FromString,
                    response_serializer=job__pb2.JobSetAutoEatResponse.SerializeToString,
            ),
            'SetGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.SetGroup,
                    request_deserializer=job__pb2.JobSetGroupRequest.FromString,
                    response_serializer=job__pb2.JobSetGroupResponse.SerializeToString,
            ),
            'SetMaxCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxCores,
                    request_deserializer=job__pb2.JobSetMaxCoresRequest.FromString,
                    response_serializer=job__pb2.JobSetMaxCoresResponse.SerializeToString,
            ),
            'SetMaxRetries': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxRetries,
                    request_deserializer=job__pb2.JobSetMaxRetriesRequest.FromString,
                    response_serializer=job__pb2.JobSetMaxRetriesResponse.SerializeToString,
            ),
            'SetMinCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinCores,
                    request_deserializer=job__pb2.JobSetMinCoresRequest.FromString,
                    response_serializer=job__pb2.JobSetMinCoresResponse.SerializeToString,
            ),
            'SetMaxGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxGpus,
                    request_deserializer=job__pb2.JobSetMaxGpusRequest.FromString,
                    response_serializer=job__pb2.JobSetMaxGpusResponse.SerializeToString,
            ),
            'SetMinGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinGpus,
                    request_deserializer=job__pb2.JobSetMinGpusRequest.FromString,
                    response_serializer=job__pb2.JobSetMinGpusResponse.SerializeToString,
            ),
            'SetPriority': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPriority,
                    request_deserializer=job__pb2.JobSetPriorityRequest.FromString,
                    response_serializer=job__pb2.JobSetPriorityResponse.SerializeToString,
            ),
            'ShutdownIfCompleted': grpc.unary_unary_rpc_method_handler(
                    servicer.ShutdownIfCompleted,
                    request_deserializer=job__pb2.JobShutdownIfCompletedRequest.FromString,
                    response_serializer=job__pb2.JobShutdownIfCompletedResponse.SerializeToString,
            ),
            'StaggerFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.StaggerFrames,
                    request_deserializer=job__pb2.JobStaggerFramesRequest.FromString,
                    response_serializer=job__pb2.JobStaggerFramesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'job.JobInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def AddComment(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, '/job.JobInterface/AddComment',
            job__pb2.JobAddCommentRequest.SerializeToString,
            job__pb2.JobAddCommentResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AddRenderPartition(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, '/job.JobInterface/AddRenderPartition',
            job__pb2.JobAddRenderPartRequest.SerializeToString,
            job__pb2.JobAddRenderPartResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AddSubscriber(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, '/job.JobInterface/AddSubscriber',
            job__pb2.JobAddSubscriberRequest.SerializeToString,
            job__pb2.JobAddSubscriberResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnFrame(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, '/job.JobInterface/CreateDependencyOnFrame',
            job__pb2.JobCreateDependencyOnFrameRequest.SerializeToString,
            job__pb2.JobCreateDependencyOnFrameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnJob(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, '/job.JobInterface/CreateDependencyOnJob',
            job__pb2.JobCreateDependencyOnJobRequest.SerializeToString,
            job__pb2.JobCreateDependencyOnJobResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnLayer(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, '/job.JobInterface/CreateDependencyOnLayer',
            job__pb2.JobCreateDependencyOnLayerRequest.SerializeToString,
            job__pb2.JobCreateDependencyOnLayerResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DropDepends(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, '/job.JobInterface/DropDepends',
            job__pb2.JobDropDependsRequest.SerializeToString,
            job__pb2.JobDropDependsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def EatFrames(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, '/job.JobInterface/EatFrames',
            job__pb2.JobEatFramesRequest.SerializeToString,
            job__pb2.JobEatFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FindJob(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, '/job.JobInterface/FindJob',
            job__pb2.JobFindJobRequest.SerializeToString,
            job__pb2.JobFindJobResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetComments(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, '/job.JobInterface/GetComments',
            job__pb2.JobGetCommentsRequest.SerializeToString,
            job__pb2.JobGetCommentsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetCurrent(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, '/job.JobInterface/GetCurrent',
            job__pb2.JobGetCurrentRequest.SerializeToString,
            job__pb2.JobGetCurrentResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDepends(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, '/job.JobInterface/GetDepends',
            job__pb2.JobGetDependsRequest.SerializeToString,
            job__pb2.JobGetDependsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetFrames(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, '/job.JobInterface/GetFrames',
            job__pb2.JobGetFramesRequest.SerializeToString,
            job__pb2.JobGetFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetJob(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, '/job.JobInterface/GetJob',
            job__pb2.JobGetJobRequest.SerializeToString,
            job__pb2.JobGetJobResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetJobs(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, '/job.JobInterface/GetJobs',
            job__pb2.JobGetJobsRequest.SerializeToString,
            job__pb2.JobGetJobsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetJobNames(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, '/job.JobInterface/GetJobNames',
            job__pb2.JobGetJobNamesRequest.SerializeToString,
            job__pb2.JobGetJobNamesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetLayers(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, '/job.JobInterface/GetLayers',
            job__pb2.JobGetLayersRequest.SerializeToString,
            job__pb2.JobGetLayersResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetUpdatedFrames(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, '/job.JobInterface/GetUpdatedFrames',
            job__pb2.JobGetUpdatedFramesRequest.SerializeToString,
            job__pb2.JobGetUpdatedFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWhatDependsOnThis(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, '/job.JobInterface/GetWhatDependsOnThis',
            job__pb2.JobGetWhatDependsOnThisRequest.SerializeToString,
            job__pb2.JobGetWhatDependsOnThisResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWhatThisDependsOn(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, '/job.JobInterface/GetWhatThisDependsOn',
            job__pb2.JobGetWhatThisDependsOnRequest.SerializeToString,
            job__pb2.JobGetWhatThisDependsOnResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def IsJobPending(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, '/job.JobInterface/IsJobPending',
            job__pb2.JobIsJobPendingRequest.SerializeToString,
            job__pb2.JobIsJobPendingResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Kill(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, '/job.JobInterface/Kill',
            job__pb2.JobKillRequest.SerializeToString,
            job__pb2.JobKillResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def KillFrames(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, '/job.JobInterface/KillFrames',
            job__pb2.JobKillFramesRequest.SerializeToString,
            job__pb2.JobKillFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LaunchSpecAndWait(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, '/job.JobInterface/LaunchSpecAndWait',
            job__pb2.JobLaunchSpecAndWaitRequest.SerializeToString,
            job__pb2.JobLaunchSpecAndWaitResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LaunchSpec(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, '/job.JobInterface/LaunchSpec',
            job__pb2.JobLaunchSpecRequest.SerializeToString,
            job__pb2.JobLaunchSpecResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarkAsWaiting(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, '/job.JobInterface/MarkAsWaiting',
            job__pb2.JobMarkAsWaitingRequest.SerializeToString,
            job__pb2.JobMarkAsWaitingResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarkDoneFrames(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, '/job.JobInterface/MarkDoneFrames',
            job__pb2.JobMarkDoneFramesRequest.SerializeToString,
            job__pb2.JobMarkDoneFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Pause(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, '/job.JobInterface/Pause',
            job__pb2.JobPauseRequest.SerializeToString,
            job__pb2.JobPauseResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReorderFrames(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, '/job.JobInterface/ReorderFrames',
            job__pb2.JobReorderFramesRequest.SerializeToString,
            job__pb2.JobReorderFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Resume(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, '/job.JobInterface/Resume',
            job__pb2.JobResumeRequest.SerializeToString,
            job__pb2.JobResumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RetryFrames(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, '/job.JobInterface/RetryFrames',
            job__pb2.JobRetryFramesRequest.SerializeToString,
            job__pb2.JobRetryFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RunFilters(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, '/job.JobInterface/RunFilters',
            job__pb2.JobRunFiltersRequest.SerializeToString,
            job__pb2.JobRunFiltersResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetAutoEat(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, '/job.JobInterface/SetAutoEat',
            job__pb2.JobSetAutoEatRequest.SerializeToString,
            job__pb2.JobSetAutoEatResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetGroup(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, '/job.JobInterface/SetGroup',
            job__pb2.JobSetGroupRequest.SerializeToString,
            job__pb2.JobSetGroupResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxCores(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, '/job.JobInterface/SetMaxCores',
            job__pb2.JobSetMaxCoresRequest.SerializeToString,
            job__pb2.JobSetMaxCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxRetries(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, '/job.JobInterface/SetMaxRetries',
            job__pb2.JobSetMaxRetriesRequest.SerializeToString,
            job__pb2.JobSetMaxRetriesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinCores(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, '/job.JobInterface/SetMinCores',
            job__pb2.JobSetMinCoresRequest.SerializeToString,
            job__pb2.JobSetMinCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxGpus(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, '/job.JobInterface/SetMaxGpus',
            job__pb2.JobSetMaxGpusRequest.SerializeToString,
            job__pb2.JobSetMaxGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinGpus(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, '/job.JobInterface/SetMinGpus',
            job__pb2.JobSetMinGpusRequest.SerializeToString,
            job__pb2.JobSetMinGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetPriority(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, '/job.JobInterface/SetPriority',
            job__pb2.JobSetPriorityRequest.SerializeToString,
            job__pb2.JobSetPriorityResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ShutdownIfCompleted(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, '/job.JobInterface/ShutdownIfCompleted',
            job__pb2.JobShutdownIfCompletedRequest.SerializeToString,
            job__pb2.JobShutdownIfCompletedResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StaggerFrames(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, '/job.JobInterface/StaggerFrames',
            job__pb2.JobStaggerFramesRequest.SerializeToString,
            job__pb2.JobStaggerFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.AddLimit = channel.unary_unary(
                '/job.LayerInterface/AddLimit',
                request_serializer=job__pb2.LayerAddLimitRequest.SerializeToString,
                response_deserializer=job__pb2.LayerAddLimitResponse.FromString,
                )
        self.AddRenderPartition = channel.unary_unary(
                '/job.LayerInterface/AddRenderPartition',
                request_serializer=job__pb2.LayerAddRenderPartitionRequest.SerializeToString,
                response_deserializer=job__pb2.LayerAddRenderPartitionResponse.FromString,
                )
        self.CreateDependencyOnFrame = channel.unary_unary(
                '/job.LayerInterface/CreateDependencyOnFrame',
                request_serializer=job__pb2.LayerCreateDependOnFrameRequest.SerializeToString,
                response_deserializer=job__pb2.LayerCreateDependOnFrameResponse.FromString,
                )
        self.CreateDependencyOnJob = channel.unary_unary(
                '/job.LayerInterface/CreateDependencyOnJob',
                request_serializer=job__pb2.LayerCreateDependOnJobRequest.SerializeToString,
                response_deserializer=job__pb2.LayerCreateDependOnJobResponse.FromString,
                )
        self.CreateDependencyOnLayer = channel.unary_unary(
                '/job.LayerInterface/CreateDependencyOnLayer',
                request_serializer=job__pb2.LayerCreateDependOnLayerRequest.SerializeToString,
                response_deserializer=job__pb2.LayerCreateDependOnLayerResponse.FromString,
                )
        self.CreateFrameByFrameDependency = channel.unary_unary(
                '/job.LayerInterface/CreateFrameByFrameDependency',
                request_serializer=job__pb2.LayerCreateFrameByFrameDependRequest.SerializeToString,
                response_deserializer=job__pb2.LayerCreateFrameByFrameDependResponse.FromString,
                )
        self.DropDepends = channel.unary_unary(
                '/job.LayerInterface/DropDepends',
                request_serializer=job__pb2.LayerDropDependsRequest.SerializeToString,
                response_deserializer=job__pb2.LayerDropDependsResponse.FromString,
                )
        self.DropLimit = channel.unary_unary(
                '/job.LayerInterface/DropLimit',
                request_serializer=job__pb2.LayerDropLimitRequest.SerializeToString,
                response_deserializer=job__pb2.LayerDropLimitResponse.FromString,
                )
        self.EatFrames = channel.unary_unary(
                '/job.LayerInterface/EatFrames',
                request_serializer=job__pb2.LayerEatFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerEatFramesResponse.FromString,
                )
        self.EnableMemoryOptimizer = channel.unary_unary(
                '/job.LayerInterface/EnableMemoryOptimizer',
                request_serializer=job__pb2.LayerEnableMemoryOptimizerRequest.SerializeToString,
                response_deserializer=job__pb2.LayerEnableMemoryOptimizerResponse.FromString,
                )
        self.FindLayer = channel.unary_unary(
                '/job.LayerInterface/FindLayer',
                request_serializer=job__pb2.LayerFindLayerRequest.SerializeToString,
                response_deserializer=job__pb2.LayerFindLayerResponse.FromString,
                )
        self.GetFrames = channel.unary_unary(
                '/job.LayerInterface/GetFrames',
                request_serializer=job__pb2.LayerGetFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerGetFramesResponse.FromString,
                )
        self.GetLayer = channel.unary_unary(
                '/job.LayerInterface/GetLayer',
                request_serializer=job__pb2.LayerGetLayerRequest.SerializeToString,
                response_deserializer=job__pb2.LayerGetLayerResponse.FromString,
                )
        self.GetLimits = channel.unary_unary(
                '/job.LayerInterface/GetLimits',
                request_serializer=job__pb2.LayerGetLimitsRequest.SerializeToString,
                response_deserializer=job__pb2.LayerGetLimitsResponse.FromString,
                )
        self.GetOutputPaths = channel.unary_unary(
                '/job.LayerInterface/GetOutputPaths',
                request_serializer=job__pb2.LayerGetOutputPathsRequest.SerializeToString,
                response_deserializer=job__pb2.LayerGetOutputPathsResponse.FromString,
                )
        self.GetWhatThisDependsOn = channel.unary_unary(
                '/job.LayerInterface/GetWhatThisDependsOn',
                request_serializer=job__pb2.LayerGetWhatThisDependsOnRequest.SerializeToString,
                response_deserializer=job__pb2.LayerGetWhatThisDependsOnResponse.FromString,
                )
        self.GetWhatDependsOnThis = channel.unary_unary(
                '/job.LayerInterface/GetWhatDependsOnThis',
                request_serializer=job__pb2.LayerGetWhatDependsOnThisRequest.SerializeToString,
                response_deserializer=job__pb2.LayerGetWhatDependsOnThisResponse.FromString,
                )
        self.KillFrames = channel.unary_unary(
                '/job.LayerInterface/KillFrames',
                request_serializer=job__pb2.LayerKillFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerKillFramesResponse.FromString,
                )
        self.MarkdoneFrames = channel.unary_unary(
                '/job.LayerInterface/MarkdoneFrames',
                request_serializer=job__pb2.LayerMarkdoneFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerMarkdoneFramesResponse.FromString,
                )
        self.RegisterOutputPath = channel.unary_unary(
                '/job.LayerInterface/RegisterOutputPath',
                request_serializer=job__pb2.LayerRegisterOutputPathRequest.SerializeToString,
                response_deserializer=job__pb2.LayerRegisterOutputPathResponse.FromString,
                )
        self.ReorderFrames = channel.unary_unary(
                '/job.LayerInterface/ReorderFrames',
                request_serializer=job__pb2.LayerReorderFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerReorderFramesResponse.FromString,
                )
        self.RetryFrames = channel.unary_unary(
                '/job.LayerInterface/RetryFrames',
                request_serializer=job__pb2.LayerRetryFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerRetryFramesResponse.FromString,
                )
        self.SetMaxCores = channel.unary_unary(
                '/job.LayerInterface/SetMaxCores',
                request_serializer=job__pb2.LayerSetMaxCoresRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMaxCoresResponse.FromString,
                )
        self.SetMinCores = channel.unary_unary(
                '/job.LayerInterface/SetMinCores',
                request_serializer=job__pb2.LayerSetMinCoresRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMinCoresResponse.FromString,
                )
        self.SetMaxGpus = channel.unary_unary(
                '/job.LayerInterface/SetMaxGpus',
                request_serializer=job__pb2.LayerSetMaxGpusRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMaxGpusResponse.FromString,
                )
        self.SetMinGpus = channel.unary_unary(
                '/job.LayerInterface/SetMinGpus',
                request_serializer=job__pb2.LayerSetMinGpusRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMinGpusResponse.FromString,
                )
        self.SetMinGpuMemory = channel.unary_unary(
                '/job.LayerInterface/SetMinGpuMemory',
                request_serializer=job__pb2.LayerSetMinGpuMemoryRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMinGpuMemoryResponse.FromString,
                )
        self.SetMinGpu = channel.unary_unary(
                '/job.LayerInterface/SetMinGpu',
                request_serializer=job__pb2.LayerSetMinGpuRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMinGpuResponse.FromString,
                )
        self.SetMinMemory = channel.unary_unary(
                '/job.LayerInterface/SetMinMemory',
                request_serializer=job__pb2.LayerSetMinMemoryRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetMinMemoryResponse.FromString,
                )
        self.SetTags = channel.unary_unary(
                '/job.LayerInterface/SetTags',
                request_serializer=job__pb2.LayerSetTagsRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetTagsResponse.FromString,
                )
        self.SetThreadable = channel.unary_unary(
                '/job.LayerInterface/SetThreadable',
                request_serializer=job__pb2.LayerSetThreadableRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetThreadableResponse.FromString,
                )
        self.SetTimeout = channel.unary_unary(
                '/job.LayerInterface/SetTimeout',
                request_serializer=job__pb2.LayerSetTimeoutRequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetTimeoutResponse.FromString,
                )
        self.SetTimeoutLLU = channel.unary_unary(
                '/job.LayerInterface/SetTimeoutLLU',
                request_serializer=job__pb2.LayerSetTimeoutLLURequest.SerializeToString,
                response_deserializer=job__pb2.LayerSetTimeoutLLUResponse.FromString,
                )
        self.StaggerFrames = channel.unary_unary(
                '/job.LayerInterface/StaggerFrames',
                request_serializer=job__pb2.LayerStaggerFramesRequest.SerializeToString,
                response_deserializer=job__pb2.LayerStaggerFramesResponse.FromString,
                )


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

    def AddLimit(self, request, context):
        """Add Limit to the Layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddRenderPartition(self, request, context):
        """Add RenderPartition to Layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnFrame(self, request, context):
        """Setup and return a LayerOnFrame dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnJob(self, request, context):
        """Setup and return a LayerOnJob dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDependencyOnLayer(self, request, context):
        """Setup and return a LayerOnLayer dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateFrameByFrameDependency(self, request, context):
        """Setup and return a FrameByFrame dependency
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropDepends(self, request, context):
        """Drops every dependency that is causing this layer not to run.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropLimit(self, request, context):
        """Drop the limit from the specified layer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EatFrames(self, request, context):
        """Eat the Frames of this Layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EnableMemoryOptimizer(self, request, context):
        """When disabled, This will stop Cuebot from lowering the amount of memory required for a given layer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindLayer(self, request, context):
        """Finds a layer in a pending job based the job and layer name
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetFrames(self, request, context):
        """Get the frames that match the FrameSearchCriteria
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetLayer(self, request, context):
        """Finds a layer in a pending job from its unique ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetLimits(self, request, context):
        """Return a list of the limits on the specified layer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetOutputPaths(self, request, context):
        """Return a list of all registered output paths.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWhatThisDependsOn(self, request, context):
        """Returns a list of dependencies that this frame depends on.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWhatDependsOnThis(self, request, context):
        """Returns a list of dependencies setup to depend on this layer.  This includes all types of depends, not just
        OnLayer dependencies.  This will not return any frame on frame dependencies that are part of a FrameByFrame
        depend.  It will return a single element that represents the entire dependency.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def KillFrames(self, request, context):
        """Kill Frames associated with this layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarkdoneFrames(self, request, context):
        """Mark the frames of this layer done
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterOutputPath(self, request, context):
        """Register an output with the given layer.  The output paths are sent in the opencue email.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReorderFrames(self, request, context):
        """Reorders the specified frame range on this job.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RetryFrames(self, request, context):
        """Retry the Frames of this Layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxCores(self, request, context):
        """The maximum number of cores to run on a given frame within this layer.  Fractional core values are not allowed
        with this setting.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinCores(self, request, context):
        """Set the Min Cores for this layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMaxGpus(self, request, context):
        """The maximum number of Gpu to run on a given frame within this layer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinGpus(self, request, context):
        """Set the Min Gpus for this layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinGpuMemory(self, request, context):
        """Set the Min gpu memory value for the layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinGpu(self, request, context):
        """[Deprecated] Set the Min gpu memory value for the layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetMinMemory(self, request, context):
        """Set the Min Memory value for the layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetTags(self, request, context):
        """Set tags on the layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetThreadable(self, request, context):
        """Set whether the layer is threadable or not
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetTimeout(self, request, context):
        """Set whether the timeout for frames in the layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetTimeoutLLU(self, request, context):
        """Set whether the LLU timeout for frames in the layer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StaggerFrames(self, request, context):
        """Staggers the specified frame range.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_LayerInterfaceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AddLimit': grpc.unary_unary_rpc_method_handler(
                    servicer.AddLimit,
                    request_deserializer=job__pb2.LayerAddLimitRequest.FromString,
                    response_serializer=job__pb2.LayerAddLimitResponse.SerializeToString,
            ),
            'AddRenderPartition': grpc.unary_unary_rpc_method_handler(
                    servicer.AddRenderPartition,
                    request_deserializer=job__pb2.LayerAddRenderPartitionRequest.FromString,
                    response_serializer=job__pb2.LayerAddRenderPartitionResponse.SerializeToString,
            ),
            'CreateDependencyOnFrame': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnFrame,
                    request_deserializer=job__pb2.LayerCreateDependOnFrameRequest.FromString,
                    response_serializer=job__pb2.LayerCreateDependOnFrameResponse.SerializeToString,
            ),
            'CreateDependencyOnJob': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnJob,
                    request_deserializer=job__pb2.LayerCreateDependOnJobRequest.FromString,
                    response_serializer=job__pb2.LayerCreateDependOnJobResponse.SerializeToString,
            ),
            'CreateDependencyOnLayer': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDependencyOnLayer,
                    request_deserializer=job__pb2.LayerCreateDependOnLayerRequest.FromString,
                    response_serializer=job__pb2.LayerCreateDependOnLayerResponse.SerializeToString,
            ),
            'CreateFrameByFrameDependency': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateFrameByFrameDependency,
                    request_deserializer=job__pb2.LayerCreateFrameByFrameDependRequest.FromString,
                    response_serializer=job__pb2.LayerCreateFrameByFrameDependResponse.SerializeToString,
            ),
            'DropDepends': grpc.unary_unary_rpc_method_handler(
                    servicer.DropDepends,
                    request_deserializer=job__pb2.LayerDropDependsRequest.FromString,
                    response_serializer=job__pb2.LayerDropDependsResponse.SerializeToString,
            ),
            'DropLimit': grpc.unary_unary_rpc_method_handler(
                    servicer.DropLimit,
                    request_deserializer=job__pb2.LayerDropLimitRequest.FromString,
                    response_serializer=job__pb2.LayerDropLimitResponse.SerializeToString,
            ),
            'EatFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.EatFrames,
                    request_deserializer=job__pb2.LayerEatFramesRequest.FromString,
                    response_serializer=job__pb2.LayerEatFramesResponse.SerializeToString,
            ),
            'EnableMemoryOptimizer': grpc.unary_unary_rpc_method_handler(
                    servicer.EnableMemoryOptimizer,
                    request_deserializer=job__pb2.LayerEnableMemoryOptimizerRequest.FromString,
                    response_serializer=job__pb2.LayerEnableMemoryOptimizerResponse.SerializeToString,
            ),
            'FindLayer': grpc.unary_unary_rpc_method_handler(
                    servicer.FindLayer,
                    request_deserializer=job__pb2.LayerFindLayerRequest.FromString,
                    response_serializer=job__pb2.LayerFindLayerResponse.SerializeToString,
            ),
            'GetFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.GetFrames,
                    request_deserializer=job__pb2.LayerGetFramesRequest.FromString,
                    response_serializer=job__pb2.LayerGetFramesResponse.SerializeToString,
            ),
            'GetLayer': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLayer,
                    request_deserializer=job__pb2.LayerGetLayerRequest.FromString,
                    response_serializer=job__pb2.LayerGetLayerResponse.SerializeToString,
            ),
            'GetLimits': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLimits,
                    request_deserializer=job__pb2.LayerGetLimitsRequest.FromString,
                    response_serializer=job__pb2.LayerGetLimitsResponse.SerializeToString,
            ),
            'GetOutputPaths': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOutputPaths,
                    request_deserializer=job__pb2.LayerGetOutputPathsRequest.FromString,
                    response_serializer=job__pb2.LayerGetOutputPathsResponse.SerializeToString,
            ),
            'GetWhatThisDependsOn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWhatThisDependsOn,
                    request_deserializer=job__pb2.LayerGetWhatThisDependsOnRequest.FromString,
                    response_serializer=job__pb2.LayerGetWhatThisDependsOnResponse.SerializeToString,
            ),
            'GetWhatDependsOnThis': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWhatDependsOnThis,
                    request_deserializer=job__pb2.LayerGetWhatDependsOnThisRequest.FromString,
                    response_serializer=job__pb2.LayerGetWhatDependsOnThisResponse.SerializeToString,
            ),
            'KillFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.KillFrames,
                    request_deserializer=job__pb2.LayerKillFramesRequest.FromString,
                    response_serializer=job__pb2.LayerKillFramesResponse.SerializeToString,
            ),
            'MarkdoneFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.MarkdoneFrames,
                    request_deserializer=job__pb2.LayerMarkdoneFramesRequest.FromString,
                    response_serializer=job__pb2.LayerMarkdoneFramesResponse.SerializeToString,
            ),
            'RegisterOutputPath': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterOutputPath,
                    request_deserializer=job__pb2.LayerRegisterOutputPathRequest.FromString,
                    response_serializer=job__pb2.LayerRegisterOutputPathResponse.SerializeToString,
            ),
            'ReorderFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.ReorderFrames,
                    request_deserializer=job__pb2.LayerReorderFramesRequest.FromString,
                    response_serializer=job__pb2.LayerReorderFramesResponse.SerializeToString,
            ),
            'RetryFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.RetryFrames,
                    request_deserializer=job__pb2.LayerRetryFramesRequest.FromString,
                    response_serializer=job__pb2.LayerRetryFramesResponse.SerializeToString,
            ),
            'SetMaxCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxCores,
                    request_deserializer=job__pb2.LayerSetMaxCoresRequest.FromString,
                    response_serializer=job__pb2.LayerSetMaxCoresResponse.SerializeToString,
            ),
            'SetMinCores': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinCores,
                    request_deserializer=job__pb2.LayerSetMinCoresRequest.FromString,
                    response_serializer=job__pb2.LayerSetMinCoresResponse.SerializeToString,
            ),
            'SetMaxGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMaxGpus,
                    request_deserializer=job__pb2.LayerSetMaxGpusRequest.FromString,
                    response_serializer=job__pb2.LayerSetMaxGpusResponse.SerializeToString,
            ),
            'SetMinGpus': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinGpus,
                    request_deserializer=job__pb2.LayerSetMinGpusRequest.FromString,
                    response_serializer=job__pb2.LayerSetMinGpusResponse.SerializeToString,
            ),
            'SetMinGpuMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinGpuMemory,
                    request_deserializer=job__pb2.LayerSetMinGpuMemoryRequest.FromString,
                    response_serializer=job__pb2.LayerSetMinGpuMemoryResponse.SerializeToString,
            ),
            'SetMinGpu': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinGpu,
                    request_deserializer=job__pb2.LayerSetMinGpuRequest.FromString,
                    response_serializer=job__pb2.LayerSetMinGpuResponse.SerializeToString,
            ),
            'SetMinMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMinMemory,
                    request_deserializer=job__pb2.LayerSetMinMemoryRequest.FromString,
                    response_serializer=job__pb2.LayerSetMinMemoryResponse.SerializeToString,
            ),
            'SetTags': grpc.unary_unary_rpc_method_handler(
                    servicer.SetTags,
                    request_deserializer=job__pb2.LayerSetTagsRequest.FromString,
                    response_serializer=job__pb2.LayerSetTagsResponse.SerializeToString,
            ),
            'SetThreadable': grpc.unary_unary_rpc_method_handler(
                    servicer.SetThreadable,
                    request_deserializer=job__pb2.LayerSetThreadableRequest.FromString,
                    response_serializer=job__pb2.LayerSetThreadableResponse.SerializeToString,
            ),
            'SetTimeout': grpc.unary_unary_rpc_method_handler(
                    servicer.SetTimeout,
                    request_deserializer=job__pb2.LayerSetTimeoutRequest.FromString,
                    response_serializer=job__pb2.LayerSetTimeoutResponse.SerializeToString,
            ),
            'SetTimeoutLLU': grpc.unary_unary_rpc_method_handler(
                    servicer.SetTimeoutLLU,
                    request_deserializer=job__pb2.LayerSetTimeoutLLURequest.FromString,
                    response_serializer=job__pb2.LayerSetTimeoutLLUResponse.SerializeToString,
            ),
            'StaggerFrames': grpc.unary_unary_rpc_method_handler(
                    servicer.StaggerFrames,
                    request_deserializer=job__pb2.LayerStaggerFramesRequest.FromString,
                    response_serializer=job__pb2.LayerStaggerFramesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'job.LayerInterface', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def AddLimit(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, '/job.LayerInterface/AddLimit',
            job__pb2.LayerAddLimitRequest.SerializeToString,
            job__pb2.LayerAddLimitResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AddRenderPartition(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, '/job.LayerInterface/AddRenderPartition',
            job__pb2.LayerAddRenderPartitionRequest.SerializeToString,
            job__pb2.LayerAddRenderPartitionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnFrame(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, '/job.LayerInterface/CreateDependencyOnFrame',
            job__pb2.LayerCreateDependOnFrameRequest.SerializeToString,
            job__pb2.LayerCreateDependOnFrameResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnJob(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, '/job.LayerInterface/CreateDependencyOnJob',
            job__pb2.LayerCreateDependOnJobRequest.SerializeToString,
            job__pb2.LayerCreateDependOnJobResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateDependencyOnLayer(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, '/job.LayerInterface/CreateDependencyOnLayer',
            job__pb2.LayerCreateDependOnLayerRequest.SerializeToString,
            job__pb2.LayerCreateDependOnLayerResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateFrameByFrameDependency(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, '/job.LayerInterface/CreateFrameByFrameDependency',
            job__pb2.LayerCreateFrameByFrameDependRequest.SerializeToString,
            job__pb2.LayerCreateFrameByFrameDependResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DropDepends(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, '/job.LayerInterface/DropDepends',
            job__pb2.LayerDropDependsRequest.SerializeToString,
            job__pb2.LayerDropDependsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DropLimit(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, '/job.LayerInterface/DropLimit',
            job__pb2.LayerDropLimitRequest.SerializeToString,
            job__pb2.LayerDropLimitResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def EatFrames(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, '/job.LayerInterface/EatFrames',
            job__pb2.LayerEatFramesRequest.SerializeToString,
            job__pb2.LayerEatFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def EnableMemoryOptimizer(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, '/job.LayerInterface/EnableMemoryOptimizer',
            job__pb2.LayerEnableMemoryOptimizerRequest.SerializeToString,
            job__pb2.LayerEnableMemoryOptimizerResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FindLayer(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, '/job.LayerInterface/FindLayer',
            job__pb2.LayerFindLayerRequest.SerializeToString,
            job__pb2.LayerFindLayerResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetFrames(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, '/job.LayerInterface/GetFrames',
            job__pb2.LayerGetFramesRequest.SerializeToString,
            job__pb2.LayerGetFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetLayer(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, '/job.LayerInterface/GetLayer',
            job__pb2.LayerGetLayerRequest.SerializeToString,
            job__pb2.LayerGetLayerResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetLimits(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, '/job.LayerInterface/GetLimits',
            job__pb2.LayerGetLimitsRequest.SerializeToString,
            job__pb2.LayerGetLimitsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetOutputPaths(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, '/job.LayerInterface/GetOutputPaths',
            job__pb2.LayerGetOutputPathsRequest.SerializeToString,
            job__pb2.LayerGetOutputPathsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWhatThisDependsOn(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, '/job.LayerInterface/GetWhatThisDependsOn',
            job__pb2.LayerGetWhatThisDependsOnRequest.SerializeToString,
            job__pb2.LayerGetWhatThisDependsOnResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWhatDependsOnThis(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, '/job.LayerInterface/GetWhatDependsOnThis',
            job__pb2.LayerGetWhatDependsOnThisRequest.SerializeToString,
            job__pb2.LayerGetWhatDependsOnThisResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def KillFrames(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, '/job.LayerInterface/KillFrames',
            job__pb2.LayerKillFramesRequest.SerializeToString,
            job__pb2.LayerKillFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarkdoneFrames(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, '/job.LayerInterface/MarkdoneFrames',
            job__pb2.LayerMarkdoneFramesRequest.SerializeToString,
            job__pb2.LayerMarkdoneFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterOutputPath(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, '/job.LayerInterface/RegisterOutputPath',
            job__pb2.LayerRegisterOutputPathRequest.SerializeToString,
            job__pb2.LayerRegisterOutputPathResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ReorderFrames(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, '/job.LayerInterface/ReorderFrames',
            job__pb2.LayerReorderFramesRequest.SerializeToString,
            job__pb2.LayerReorderFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RetryFrames(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, '/job.LayerInterface/RetryFrames',
            job__pb2.LayerRetryFramesRequest.SerializeToString,
            job__pb2.LayerRetryFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxCores(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, '/job.LayerInterface/SetMaxCores',
            job__pb2.LayerSetMaxCoresRequest.SerializeToString,
            job__pb2.LayerSetMaxCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinCores(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, '/job.LayerInterface/SetMinCores',
            job__pb2.LayerSetMinCoresRequest.SerializeToString,
            job__pb2.LayerSetMinCoresResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMaxGpus(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, '/job.LayerInterface/SetMaxGpus',
            job__pb2.LayerSetMaxGpusRequest.SerializeToString,
            job__pb2.LayerSetMaxGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinGpus(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, '/job.LayerInterface/SetMinGpus',
            job__pb2.LayerSetMinGpusRequest.SerializeToString,
            job__pb2.LayerSetMinGpusResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinGpuMemory(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, '/job.LayerInterface/SetMinGpuMemory',
            job__pb2.LayerSetMinGpuMemoryRequest.SerializeToString,
            job__pb2.LayerSetMinGpuMemoryResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinGpu(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, '/job.LayerInterface/SetMinGpu',
            job__pb2.LayerSetMinGpuRequest.SerializeToString,
            job__pb2.LayerSetMinGpuResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMinMemory(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, '/job.LayerInterface/SetMinMemory',
            job__pb2.LayerSetMinMemoryRequest.SerializeToString,
            job__pb2.LayerSetMinMemoryResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetTags(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, '/job.LayerInterface/SetTags',
            job__pb2.LayerSetTagsRequest.SerializeToString,
            job__pb2.LayerSetTagsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetThreadable(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, '/job.LayerInterface/SetThreadable',
            job__pb2.LayerSetThreadableRequest.SerializeToString,
            job__pb2.LayerSetThreadableResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetTimeout(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, '/job.LayerInterface/SetTimeout',
            job__pb2.LayerSetTimeoutRequest.SerializeToString,
            job__pb2.LayerSetTimeoutResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetTimeoutLLU(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, '/job.LayerInterface/SetTimeoutLLU',
            job__pb2.LayerSetTimeoutLLURequest.SerializeToString,
            job__pb2.LayerSetTimeoutLLUResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StaggerFrames(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, '/job.LayerInterface/StaggerFrames',
            job__pb2.LayerStaggerFramesRequest.SerializeToString,
            job__pb2.LayerStaggerFramesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)