# 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 rover_pb2 as rover__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 rover_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 RoverServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.set_velocity = channel.unary_unary(
                '/rover.RoverService/set_velocity',
                request_serializer=rover__pb2.VelocityCommand.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.set_differential_speed = channel.unary_unary(
                '/rover.RoverService/set_differential_speed',
                request_serializer=rover__pb2.DifferentialCommand.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.set_rc_channels = channel.unary_unary(
                '/rover.RoverService/set_rc_channels',
                request_serializer=rover__pb2.RCChannelsCommand.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.stream_rc_channels = channel.stream_stream(
                '/rover.RoverService/stream_rc_channels',
                request_serializer=rover__pb2.RCChannelsCommand.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.stop = channel.unary_unary(
                '/rover.RoverService/stop',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.goto = channel.unary_unary(
                '/rover.RoverService/goto',
                request_serializer=rover__pb2.GotoCommand.SerializeToString,
                response_deserializer=rover__pb2.GotoAck.FromString,
                _registered_method=True)
        self.goto_stream_position = channel.unary_stream(
                '/rover.RoverService/goto_stream_position',
                request_serializer=rover__pb2.GotoCommand.SerializeToString,
                response_deserializer=rover__pb2.GotoProgress.FromString,
                _registered_method=True)
        self.goto_cancel = channel.unary_unary(
                '/rover.RoverService/goto_cancel',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.goto_status = channel.unary_unary(
                '/rover.RoverService/goto_status',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.GotoProgress.FromString,
                _registered_method=True)
        self.led_control = channel.unary_unary(
                '/rover.RoverService/led_control',
                request_serializer=rover__pb2.LedCommand.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.led_custom = channel.unary_unary(
                '/rover.RoverService/led_custom',
                request_serializer=rover__pb2.LedCustomCommand.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.beep = channel.unary_unary(
                '/rover.RoverService/beep',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.moo = channel.unary_unary(
                '/rover.RoverService/moo',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)
        self.get_telemetry = channel.unary_unary(
                '/rover.RoverService/get_telemetry',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.TelemetryData.FromString,
                _registered_method=True)
        self.stream_telemetry = channel.unary_stream(
                '/rover.RoverService/stream_telemetry',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.TelemetryData.FromString,
                _registered_method=True)
        self.get_status = channel.unary_unary(
                '/rover.RoverService/get_status',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.RoverStatus.FromString,
                _registered_method=True)
        self.get_battery_status = channel.unary_unary(
                '/rover.RoverService/get_battery_status',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.BatteryData.FromString,
                _registered_method=True)
        self.emergency_stop = channel.unary_unary(
                '/rover.RoverService/emergency_stop',
                request_serializer=rover__pb2.Empty.SerializeToString,
                response_deserializer=rover__pb2.CommandAck.FromString,
                _registered_method=True)


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

    def set_velocity(self, request, context):
        """Управление движением
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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

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

    def led_control(self, request, context):
        """Управление периферией
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def led_custom(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 beep(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 moo(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 get_telemetry(self, request, context):
        """Получение данных
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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

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

    def emergency_stop(self, request, context):
        """Доп методы
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_RoverServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'set_velocity': grpc.unary_unary_rpc_method_handler(
                    servicer.set_velocity,
                    request_deserializer=rover__pb2.VelocityCommand.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'set_differential_speed': grpc.unary_unary_rpc_method_handler(
                    servicer.set_differential_speed,
                    request_deserializer=rover__pb2.DifferentialCommand.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'set_rc_channels': grpc.unary_unary_rpc_method_handler(
                    servicer.set_rc_channels,
                    request_deserializer=rover__pb2.RCChannelsCommand.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'stream_rc_channels': grpc.stream_stream_rpc_method_handler(
                    servicer.stream_rc_channels,
                    request_deserializer=rover__pb2.RCChannelsCommand.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'stop': grpc.unary_unary_rpc_method_handler(
                    servicer.stop,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'goto': grpc.unary_unary_rpc_method_handler(
                    servicer.goto,
                    request_deserializer=rover__pb2.GotoCommand.FromString,
                    response_serializer=rover__pb2.GotoAck.SerializeToString,
            ),
            'goto_stream_position': grpc.unary_stream_rpc_method_handler(
                    servicer.goto_stream_position,
                    request_deserializer=rover__pb2.GotoCommand.FromString,
                    response_serializer=rover__pb2.GotoProgress.SerializeToString,
            ),
            'goto_cancel': grpc.unary_unary_rpc_method_handler(
                    servicer.goto_cancel,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'goto_status': grpc.unary_unary_rpc_method_handler(
                    servicer.goto_status,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.GotoProgress.SerializeToString,
            ),
            'led_control': grpc.unary_unary_rpc_method_handler(
                    servicer.led_control,
                    request_deserializer=rover__pb2.LedCommand.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'led_custom': grpc.unary_unary_rpc_method_handler(
                    servicer.led_custom,
                    request_deserializer=rover__pb2.LedCustomCommand.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'beep': grpc.unary_unary_rpc_method_handler(
                    servicer.beep,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'moo': grpc.unary_unary_rpc_method_handler(
                    servicer.moo,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
            'get_telemetry': grpc.unary_unary_rpc_method_handler(
                    servicer.get_telemetry,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.TelemetryData.SerializeToString,
            ),
            'stream_telemetry': grpc.unary_stream_rpc_method_handler(
                    servicer.stream_telemetry,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.TelemetryData.SerializeToString,
            ),
            'get_status': grpc.unary_unary_rpc_method_handler(
                    servicer.get_status,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.RoverStatus.SerializeToString,
            ),
            'get_battery_status': grpc.unary_unary_rpc_method_handler(
                    servicer.get_battery_status,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.BatteryData.SerializeToString,
            ),
            'emergency_stop': grpc.unary_unary_rpc_method_handler(
                    servicer.emergency_stop,
                    request_deserializer=rover__pb2.Empty.FromString,
                    response_serializer=rover__pb2.CommandAck.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'rover.RoverService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('rover.RoverService', rpc_method_handlers)


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

    @staticmethod
    def set_velocity(request,
            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,
            '/rover.RoverService/set_velocity',
            rover__pb2.VelocityCommand.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def set_differential_speed(request,
            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,
            '/rover.RoverService/set_differential_speed',
            rover__pb2.DifferentialCommand.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def set_rc_channels(request,
            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,
            '/rover.RoverService/set_rc_channels',
            rover__pb2.RCChannelsCommand.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def stream_rc_channels(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/rover.RoverService/stream_rc_channels',
            rover__pb2.RCChannelsCommand.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def stop(request,
            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,
            '/rover.RoverService/stop',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def goto(request,
            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,
            '/rover.RoverService/goto',
            rover__pb2.GotoCommand.SerializeToString,
            rover__pb2.GotoAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def goto_stream_position(request,
            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,
            '/rover.RoverService/goto_stream_position',
            rover__pb2.GotoCommand.SerializeToString,
            rover__pb2.GotoProgress.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def goto_cancel(request,
            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,
            '/rover.RoverService/goto_cancel',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def goto_status(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/rover.RoverService/goto_status',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.GotoProgress.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def led_control(request,
            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,
            '/rover.RoverService/led_control',
            rover__pb2.LedCommand.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def led_custom(request,
            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,
            '/rover.RoverService/led_custom',
            rover__pb2.LedCustomCommand.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def beep(request,
            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,
            '/rover.RoverService/beep',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def moo(request,
            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,
            '/rover.RoverService/moo',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def get_telemetry(request,
            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,
            '/rover.RoverService/get_telemetry',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.TelemetryData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def stream_telemetry(request,
            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,
            '/rover.RoverService/stream_telemetry',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.TelemetryData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def get_status(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/rover.RoverService/get_status',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.RoverStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def get_battery_status(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/rover.RoverService/get_battery_status',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.BatteryData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def emergency_stop(request,
            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,
            '/rover.RoverService/emergency_stop',
            rover__pb2.Empty.SerializeToString,
            rover__pb2.CommandAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
