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

from . import siphon_service_pb2 as siphon__service__pb2

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

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

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


class SiphonServiceStub(object):
    """Service definition for managing a single variable
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetAttribute = channel.unary_unary(
                '/siphon_service.SiphonService/GetAttribute',
                request_serializer=siphon__service__pb2.GetSiphonRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.GetSiphonResponse.FromString,
                _registered_method=True)
        self.SetAttribute = channel.unary_unary(
                '/siphon_service.SiphonService/SetAttribute',
                request_serializer=siphon__service__pb2.SetSiphonRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.SetSiphonResponse.FromString,
                _registered_method=True)
        self.InputKeyTap = channel.unary_unary(
                '/siphon_service.SiphonService/InputKeyTap',
                request_serializer=siphon__service__pb2.InputKeyTapRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.InputKeyTapResponse.FromString,
                _registered_method=True)
        self.InputKeyToggle = channel.unary_unary(
                '/siphon_service.SiphonService/InputKeyToggle',
                request_serializer=siphon__service__pb2.InputKeyToggleRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.InputKeyToggleResponse.FromString,
                _registered_method=True)
        self.MoveMouse = channel.unary_unary(
                '/siphon_service.SiphonService/MoveMouse',
                request_serializer=siphon__service__pb2.MoveMouseRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.MoveMouseResponse.FromString,
                _registered_method=True)
        self.CaptureFrame = channel.unary_unary(
                '/siphon_service.SiphonService/CaptureFrame',
                request_serializer=siphon__service__pb2.CaptureFrameRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.CaptureFrameResponse.FromString,
                _registered_method=True)
        self.ExecuteCommand = channel.unary_unary(
                '/siphon_service.SiphonService/ExecuteCommand',
                request_serializer=siphon__service__pb2.ExecuteCommandRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.ExecuteCommandResponse.FromString,
                _registered_method=True)
        self.SetProcessConfig = channel.unary_unary(
                '/siphon_service.SiphonService/SetProcessConfig',
                request_serializer=siphon__service__pb2.SetProcessConfigRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.SetProcessConfigResponse.FromString,
                _registered_method=True)
        self.InitializeMemory = channel.unary_unary(
                '/siphon_service.SiphonService/InitializeMemory',
                request_serializer=siphon__service__pb2.InitializeMemoryRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.InitializeMemoryResponse.FromString,
                _registered_method=True)
        self.InitializeInput = channel.unary_unary(
                '/siphon_service.SiphonService/InitializeInput',
                request_serializer=siphon__service__pb2.InitializeInputRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.InitializeInputResponse.FromString,
                _registered_method=True)
        self.InitializeCapture = channel.unary_unary(
                '/siphon_service.SiphonService/InitializeCapture',
                request_serializer=siphon__service__pb2.InitializeCaptureRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.InitializeCaptureResponse.FromString,
                _registered_method=True)
        self.GetServerStatus = channel.unary_unary(
                '/siphon_service.SiphonService/GetServerStatus',
                request_serializer=siphon__service__pb2.GetServerStatusRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.GetServerStatusResponse.FromString,
                _registered_method=True)
        self.StartRecording = channel.unary_unary(
                '/siphon_service.SiphonService/StartRecording',
                request_serializer=siphon__service__pb2.StartRecordingRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.StartRecordingResponse.FromString,
                _registered_method=True)
        self.StopRecording = channel.unary_unary(
                '/siphon_service.SiphonService/StopRecording',
                request_serializer=siphon__service__pb2.StopRecordingRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.StopRecordingResponse.FromString,
                _registered_method=True)
        self.GetRecordingStatus = channel.unary_unary(
                '/siphon_service.SiphonService/GetRecordingStatus',
                request_serializer=siphon__service__pb2.GetRecordingStatusRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.GetRecordingStatusResponse.FromString,
                _registered_method=True)
        self.DownloadRecording = channel.unary_stream(
                '/siphon_service.SiphonService/DownloadRecording',
                request_serializer=siphon__service__pb2.DownloadRecordingRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.RecordingChunk.FromString,
                _registered_method=True)
        self.StreamFrames = channel.unary_stream(
                '/siphon_service.SiphonService/StreamFrames',
                request_serializer=siphon__service__pb2.StreamFramesRequest.SerializeToString,
                response_deserializer=siphon__service__pb2.FrameData.FromString,
                _registered_method=True)


class SiphonServiceServicer(object):
    """Service definition for managing a single variable
    """

    def GetAttribute(self, request, context):
        """Get the current value of the variable
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetAttribute(self, request, context):
        """Set the value of the variable
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InputKeyTap(self, request, context):
        """Input a key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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

    def MoveMouse(self, request, context):
        """Move mouse
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CaptureFrame(self, request, context):
        """Capture a frame
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteCommand(self, request, context):
        """Execute a command on the remote system
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetProcessConfig(self, request, context):
        """Configuration and initialization endpoints
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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

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

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

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

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

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

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

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

    def StreamFrames(self, request, context):
        """Frame streaming endpoint
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_SiphonServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetAttribute': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAttribute,
                    request_deserializer=siphon__service__pb2.GetSiphonRequest.FromString,
                    response_serializer=siphon__service__pb2.GetSiphonResponse.SerializeToString,
            ),
            'SetAttribute': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAttribute,
                    request_deserializer=siphon__service__pb2.SetSiphonRequest.FromString,
                    response_serializer=siphon__service__pb2.SetSiphonResponse.SerializeToString,
            ),
            'InputKeyTap': grpc.unary_unary_rpc_method_handler(
                    servicer.InputKeyTap,
                    request_deserializer=siphon__service__pb2.InputKeyTapRequest.FromString,
                    response_serializer=siphon__service__pb2.InputKeyTapResponse.SerializeToString,
            ),
            'InputKeyToggle': grpc.unary_unary_rpc_method_handler(
                    servicer.InputKeyToggle,
                    request_deserializer=siphon__service__pb2.InputKeyToggleRequest.FromString,
                    response_serializer=siphon__service__pb2.InputKeyToggleResponse.SerializeToString,
            ),
            'MoveMouse': grpc.unary_unary_rpc_method_handler(
                    servicer.MoveMouse,
                    request_deserializer=siphon__service__pb2.MoveMouseRequest.FromString,
                    response_serializer=siphon__service__pb2.MoveMouseResponse.SerializeToString,
            ),
            'CaptureFrame': grpc.unary_unary_rpc_method_handler(
                    servicer.CaptureFrame,
                    request_deserializer=siphon__service__pb2.CaptureFrameRequest.FromString,
                    response_serializer=siphon__service__pb2.CaptureFrameResponse.SerializeToString,
            ),
            'ExecuteCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteCommand,
                    request_deserializer=siphon__service__pb2.ExecuteCommandRequest.FromString,
                    response_serializer=siphon__service__pb2.ExecuteCommandResponse.SerializeToString,
            ),
            'SetProcessConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.SetProcessConfig,
                    request_deserializer=siphon__service__pb2.SetProcessConfigRequest.FromString,
                    response_serializer=siphon__service__pb2.SetProcessConfigResponse.SerializeToString,
            ),
            'InitializeMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.InitializeMemory,
                    request_deserializer=siphon__service__pb2.InitializeMemoryRequest.FromString,
                    response_serializer=siphon__service__pb2.InitializeMemoryResponse.SerializeToString,
            ),
            'InitializeInput': grpc.unary_unary_rpc_method_handler(
                    servicer.InitializeInput,
                    request_deserializer=siphon__service__pb2.InitializeInputRequest.FromString,
                    response_serializer=siphon__service__pb2.InitializeInputResponse.SerializeToString,
            ),
            'InitializeCapture': grpc.unary_unary_rpc_method_handler(
                    servicer.InitializeCapture,
                    request_deserializer=siphon__service__pb2.InitializeCaptureRequest.FromString,
                    response_serializer=siphon__service__pb2.InitializeCaptureResponse.SerializeToString,
            ),
            'GetServerStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetServerStatus,
                    request_deserializer=siphon__service__pb2.GetServerStatusRequest.FromString,
                    response_serializer=siphon__service__pb2.GetServerStatusResponse.SerializeToString,
            ),
            'StartRecording': grpc.unary_unary_rpc_method_handler(
                    servicer.StartRecording,
                    request_deserializer=siphon__service__pb2.StartRecordingRequest.FromString,
                    response_serializer=siphon__service__pb2.StartRecordingResponse.SerializeToString,
            ),
            'StopRecording': grpc.unary_unary_rpc_method_handler(
                    servicer.StopRecording,
                    request_deserializer=siphon__service__pb2.StopRecordingRequest.FromString,
                    response_serializer=siphon__service__pb2.StopRecordingResponse.SerializeToString,
            ),
            'GetRecordingStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecordingStatus,
                    request_deserializer=siphon__service__pb2.GetRecordingStatusRequest.FromString,
                    response_serializer=siphon__service__pb2.GetRecordingStatusResponse.SerializeToString,
            ),
            'DownloadRecording': grpc.unary_stream_rpc_method_handler(
                    servicer.DownloadRecording,
                    request_deserializer=siphon__service__pb2.DownloadRecordingRequest.FromString,
                    response_serializer=siphon__service__pb2.RecordingChunk.SerializeToString,
            ),
            'StreamFrames': grpc.unary_stream_rpc_method_handler(
                    servicer.StreamFrames,
                    request_deserializer=siphon__service__pb2.StreamFramesRequest.FromString,
                    response_serializer=siphon__service__pb2.FrameData.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'siphon_service.SiphonService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('siphon_service.SiphonService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class SiphonService(object):
    """Service definition for managing a single variable
    """

    @staticmethod
    def GetAttribute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/GetAttribute',
            siphon__service__pb2.GetSiphonRequest.SerializeToString,
            siphon__service__pb2.GetSiphonResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetAttribute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/SetAttribute',
            siphon__service__pb2.SetSiphonRequest.SerializeToString,
            siphon__service__pb2.SetSiphonResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InputKeyTap(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/InputKeyTap',
            siphon__service__pb2.InputKeyTapRequest.SerializeToString,
            siphon__service__pb2.InputKeyTapResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InputKeyToggle(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/InputKeyToggle',
            siphon__service__pb2.InputKeyToggleRequest.SerializeToString,
            siphon__service__pb2.InputKeyToggleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MoveMouse(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/MoveMouse',
            siphon__service__pb2.MoveMouseRequest.SerializeToString,
            siphon__service__pb2.MoveMouseResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CaptureFrame(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/CaptureFrame',
            siphon__service__pb2.CaptureFrameRequest.SerializeToString,
            siphon__service__pb2.CaptureFrameResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteCommand(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/ExecuteCommand',
            siphon__service__pb2.ExecuteCommandRequest.SerializeToString,
            siphon__service__pb2.ExecuteCommandResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetProcessConfig(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/SetProcessConfig',
            siphon__service__pb2.SetProcessConfigRequest.SerializeToString,
            siphon__service__pb2.SetProcessConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitializeMemory(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/InitializeMemory',
            siphon__service__pb2.InitializeMemoryRequest.SerializeToString,
            siphon__service__pb2.InitializeMemoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitializeInput(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/InitializeInput',
            siphon__service__pb2.InitializeInputRequest.SerializeToString,
            siphon__service__pb2.InitializeInputResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitializeCapture(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/InitializeCapture',
            siphon__service__pb2.InitializeCaptureRequest.SerializeToString,
            siphon__service__pb2.InitializeCaptureResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetServerStatus(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/GetServerStatus',
            siphon__service__pb2.GetServerStatusRequest.SerializeToString,
            siphon__service__pb2.GetServerStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartRecording(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/StartRecording',
            siphon__service__pb2.StartRecordingRequest.SerializeToString,
            siphon__service__pb2.StartRecordingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopRecording(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/StopRecording',
            siphon__service__pb2.StopRecordingRequest.SerializeToString,
            siphon__service__pb2.StopRecordingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecordingStatus(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/siphon_service.SiphonService/GetRecordingStatus',
            siphon__service__pb2.GetRecordingStatusRequest.SerializeToString,
            siphon__service__pb2.GetRecordingStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DownloadRecording(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/siphon_service.SiphonService/DownloadRecording',
            siphon__service__pb2.DownloadRecordingRequest.SerializeToString,
            siphon__service__pb2.RecordingChunk.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamFrames(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/siphon_service.SiphonService/StreamFrames',
            siphon__service__pb2.StreamFramesRequest.SerializeToString,
            siphon__service__pb2.FrameData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
