# 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 robomotion import runner_pb2 as runner__pb2

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

# try:
#     from grpc._utilities import first_version_is_lower
#     _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
# except ImportError:
#     _version_not_supported = True
# 
# if _version_not_supported:
#     raise RuntimeError(
#         f'The grpc package installed is at version {GRPC_VERSION},'
#         + f' but the generated code in runner_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 RunnerStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Init = channel.unary_unary(
                '/proto.Runner/Init',
                request_serializer=runner__pb2.InitRunnerRequest.SerializeToString,
                response_deserializer=runner__pb2.Null.FromString,
                _registered_method=True)
        self.Run = channel.unary_unary(
                '/proto.Runner/Run',
                request_serializer=runner__pb2.RunRequest.SerializeToString,
                response_deserializer=runner__pb2.Null.FromString,
                _registered_method=True)
        self.Clear = channel.unary_unary(
                '/proto.Runner/Clear',
                request_serializer=runner__pb2.Null.SerializeToString,
                response_deserializer=runner__pb2.Null.FromString,
                _registered_method=True)
        self.RobotName = channel.unary_unary(
                '/proto.Runner/RobotName',
                request_serializer=runner__pb2.Null.SerializeToString,
                response_deserializer=runner__pb2.RobotNameResponse.FromString,
                _registered_method=True)


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

    def Init(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 Run(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 Clear(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 RobotName(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_RunnerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Init': grpc.unary_unary_rpc_method_handler(
                    servicer.Init,
                    request_deserializer=runner__pb2.InitRunnerRequest.FromString,
                    response_serializer=runner__pb2.Null.SerializeToString,
            ),
            'Run': grpc.unary_unary_rpc_method_handler(
                    servicer.Run,
                    request_deserializer=runner__pb2.RunRequest.FromString,
                    response_serializer=runner__pb2.Null.SerializeToString,
            ),
            'Clear': grpc.unary_unary_rpc_method_handler(
                    servicer.Clear,
                    request_deserializer=runner__pb2.Null.FromString,
                    response_serializer=runner__pb2.Null.SerializeToString,
            ),
            'RobotName': grpc.unary_unary_rpc_method_handler(
                    servicer.RobotName,
                    request_deserializer=runner__pb2.Null.FromString,
                    response_serializer=runner__pb2.RobotNameResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'proto.Runner', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('proto.Runner', rpc_method_handlers)


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

    @staticmethod
    def Init(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/proto.Runner/Init',
            runner__pb2.InitRunnerRequest.SerializeToString,
            runner__pb2.Null.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Run(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/proto.Runner/Run',
            runner__pb2.RunRequest.SerializeToString,
            runner__pb2.Null.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Clear(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/proto.Runner/Clear',
            runner__pb2.Null.SerializeToString,
            runner__pb2.Null.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RobotName(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/proto.Runner/RobotName',
            runner__pb2.Null.SerializeToString,
            runner__pb2.RobotNameResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


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

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

        Args:
            channel: A grpc.Channel.
        """


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


def add_RobotHelperServicer_to_server(servicer, server):
    rpc_method_handlers = {
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'proto.RobotHelper', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('proto.RobotHelper', rpc_method_handlers)


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


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Attach = channel.unary_unary(
                '/proto.Debug/Attach',
                request_serializer=runner__pb2.AttachRequest.SerializeToString,
                response_deserializer=runner__pb2.Nil.FromString,
                _registered_method=True)
        self.Detach = channel.unary_unary(
                '/proto.Debug/Detach',
                request_serializer=runner__pb2.DetachRequest.SerializeToString,
                response_deserializer=runner__pb2.Nil.FromString,
                _registered_method=True)


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

    def Attach(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 Detach(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DebugServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Attach': grpc.unary_unary_rpc_method_handler(
                    servicer.Attach,
                    request_deserializer=runner__pb2.AttachRequest.FromString,
                    response_serializer=runner__pb2.Nil.SerializeToString,
            ),
            'Detach': grpc.unary_unary_rpc_method_handler(
                    servicer.Detach,
                    request_deserializer=runner__pb2.DetachRequest.FromString,
                    response_serializer=runner__pb2.Nil.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'proto.Debug', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('proto.Debug', rpc_method_handlers)


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

    @staticmethod
    def Attach(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/proto.Debug/Attach',
            runner__pb2.AttachRequest.SerializeToString,
            runner__pb2.Nil.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Detach(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/proto.Debug/Detach',
            runner__pb2.DetachRequest.SerializeToString,
            runner__pb2.Nil.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
