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

import qiclib.packages.grpc.datatypes_pb2 as datatypes__pb2
import qiclib.packages.grpc.rfdc_pb2 as rfdc__pb2

GRPC_GENERATED_VERSION = '1.66.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 rfdc_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 RFdcServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetBlockStatus = channel.unary_unary(
                '/rfdc.RFdcService/GetBlockStatus',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.BlockStatus.FromString,
                _registered_method=True)
        self.GetMixerFrequency = channel.unary_unary(
                '/rfdc.RFdcService/GetMixerFrequency',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.Frequency.FromString,
                _registered_method=True)
        self.SetMixerFrequency = channel.unary_unary(
                '/rfdc.RFdcService/SetMixerFrequency',
                request_serializer=rfdc__pb2.Frequency.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetPhase = channel.unary_unary(
                '/rfdc.RFdcService/GetPhase',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.Phase.FromString,
                _registered_method=True)
        self.SetPhase = channel.unary_unary(
                '/rfdc.RFdcService/SetPhase',
                request_serializer=rfdc__pb2.Phase.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetMixerMode = channel.unary_unary(
                '/rfdc.RFdcService/GetMixerMode',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.Mode.FromString,
                _registered_method=True)
        self.SetMixerSettings = channel.unary_unary(
                '/rfdc.RFdcService/SetMixerSettings',
                request_serializer=rfdc__pb2.MixerSettings.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetDataType = channel.unary_unary(
                '/rfdc.RFdcService/GetDataType',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.DataType.FromString,
                _registered_method=True)
        self.GetInterpolation = channel.unary_unary(
                '/rfdc.RFdcService/GetInterpolation',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.Interpolation.FromString,
                _registered_method=True)
        self.SetInterpolation = channel.unary_unary(
                '/rfdc.RFdcService/SetInterpolation',
                request_serializer=rfdc__pb2.Interpolation.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetDecimation = channel.unary_unary(
                '/rfdc.RFdcService/GetDecimation',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.Decimation.FromString,
                _registered_method=True)
        self.SetDecimation = channel.unary_unary(
                '/rfdc.RFdcService/SetDecimation',
                request_serializer=rfdc__pb2.Decimation.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetInvSincFIR = channel.unary_unary(
                '/rfdc.RFdcService/GetInvSincFIR',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.InvSincFIR.FromString,
                _registered_method=True)
        self.SetInvSincFIR = channel.unary_unary(
                '/rfdc.RFdcService/SetInvSincFIR',
                request_serializer=rfdc__pb2.InvSincFIR.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.SetThresholdStickyClear = channel.unary_unary(
                '/rfdc.RFdcService/SetThresholdStickyClear',
                request_serializer=rfdc__pb2.ThresholdToUpdate.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.StartUp = channel.unary_unary(
                '/rfdc.RFdcService/StartUp',
                request_serializer=rfdc__pb2.TileIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.Shutdown = channel.unary_unary(
                '/rfdc.RFdcService/Shutdown',
                request_serializer=rfdc__pb2.TileIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.Reset = channel.unary_unary(
                '/rfdc.RFdcService/Reset',
                request_serializer=rfdc__pb2.TileIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.InterruptClear = channel.unary_unary(
                '/rfdc.RFdcService/InterruptClear',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetInterruptStatus = channel.unary_unary(
                '/rfdc.RFdcService/GetInterruptStatus',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.InterruptSettings.FromString,
                _registered_method=True)
        self.GetNyquistZone = channel.unary_unary(
                '/rfdc.RFdcService/GetNyquistZone',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=rfdc__pb2.NyquistZone.FromString,
                _registered_method=True)
        self.SetNyquistZone = channel.unary_unary(
                '/rfdc.RFdcService/SetNyquistZone',
                request_serializer=rfdc__pb2.NyquistZone.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.ReportStatus = channel.unary_unary(
                '/rfdc.RFdcService/ReportStatus',
                request_serializer=datatypes__pb2.Empty.SerializeToString,
                response_deserializer=rfdc__pb2.StatusReport.FromString,
                _registered_method=True)
        self.ResetStatus = channel.unary_unary(
                '/rfdc.RFdcService/ResetStatus',
                request_serializer=datatypes__pb2.Empty.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetDigitalAttenuation = channel.unary_unary(
                '/rfdc.RFdcService/GetDigitalAttenuation',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Double.FromString,
                _registered_method=True)
        self.SetDigitalAttenuation = channel.unary_unary(
                '/rfdc.RFdcService/SetDigitalAttenuation',
                request_serializer=rfdc__pb2.IndexedDouble.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetOutputCurrent = channel.unary_unary(
                '/rfdc.RFdcService/GetOutputCurrent',
                request_serializer=rfdc__pb2.ConverterIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Double.FromString,
                _registered_method=True)
        self.SetOutputCurrent = channel.unary_unary(
                '/rfdc.RFdcService/SetOutputCurrent',
                request_serializer=rfdc__pb2.IndexedDouble.SerializeToString,
                response_deserializer=datatypes__pb2.Double.FromString,
                _registered_method=True)


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

    def GetBlockStatus(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 GetMixerFrequency(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 SetMixerFrequency(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 GetPhase(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 SetPhase(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 GetMixerMode(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 SetMixerSettings(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 GetDataType(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 GetInterpolation(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 SetInterpolation(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 GetDecimation(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 SetDecimation(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 GetInvSincFIR(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 SetInvSincFIR(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 SetThresholdStickyClear(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 StartUp(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 Shutdown(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 Reset(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 InterruptClear(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 GetInterruptStatus(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 GetNyquistZone(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 SetNyquistZone(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 ReportStatus(self, request, context):
        """*
        @brief Return the status of the converters in the RFdc.

        @param msg None
        @return StatusReport containing further information about the RFdc status.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResetStatus(self, request, context):
        """*
        @brief Resets the status of the converters in the RFdc.

        This is necessary as the status is sticky until reset.
        @param msg None
        @return None
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetDigitalAttenuation(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 SetDigitalAttenuation(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 GetOutputCurrent(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 SetOutputCurrent(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_RFdcServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetBlockStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBlockStatus,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.BlockStatus.SerializeToString,
            ),
            'GetMixerFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMixerFrequency,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.Frequency.SerializeToString,
            ),
            'SetMixerFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMixerFrequency,
                    request_deserializer=rfdc__pb2.Frequency.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetPhase': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPhase,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.Phase.SerializeToString,
            ),
            'SetPhase': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPhase,
                    request_deserializer=rfdc__pb2.Phase.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetMixerMode': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMixerMode,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.Mode.SerializeToString,
            ),
            'SetMixerSettings': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMixerSettings,
                    request_deserializer=rfdc__pb2.MixerSettings.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetDataType': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDataType,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.DataType.SerializeToString,
            ),
            'GetInterpolation': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInterpolation,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.Interpolation.SerializeToString,
            ),
            'SetInterpolation': grpc.unary_unary_rpc_method_handler(
                    servicer.SetInterpolation,
                    request_deserializer=rfdc__pb2.Interpolation.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetDecimation': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDecimation,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.Decimation.SerializeToString,
            ),
            'SetDecimation': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDecimation,
                    request_deserializer=rfdc__pb2.Decimation.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetInvSincFIR': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInvSincFIR,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.InvSincFIR.SerializeToString,
            ),
            'SetInvSincFIR': grpc.unary_unary_rpc_method_handler(
                    servicer.SetInvSincFIR,
                    request_deserializer=rfdc__pb2.InvSincFIR.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'SetThresholdStickyClear': grpc.unary_unary_rpc_method_handler(
                    servicer.SetThresholdStickyClear,
                    request_deserializer=rfdc__pb2.ThresholdToUpdate.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'StartUp': grpc.unary_unary_rpc_method_handler(
                    servicer.StartUp,
                    request_deserializer=rfdc__pb2.TileIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'Shutdown': grpc.unary_unary_rpc_method_handler(
                    servicer.Shutdown,
                    request_deserializer=rfdc__pb2.TileIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'Reset': grpc.unary_unary_rpc_method_handler(
                    servicer.Reset,
                    request_deserializer=rfdc__pb2.TileIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'InterruptClear': grpc.unary_unary_rpc_method_handler(
                    servicer.InterruptClear,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetInterruptStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInterruptStatus,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.InterruptSettings.SerializeToString,
            ),
            'GetNyquistZone': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNyquistZone,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=rfdc__pb2.NyquistZone.SerializeToString,
            ),
            'SetNyquistZone': grpc.unary_unary_rpc_method_handler(
                    servicer.SetNyquistZone,
                    request_deserializer=rfdc__pb2.NyquistZone.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'ReportStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportStatus,
                    request_deserializer=datatypes__pb2.Empty.FromString,
                    response_serializer=rfdc__pb2.StatusReport.SerializeToString,
            ),
            'ResetStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetStatus,
                    request_deserializer=datatypes__pb2.Empty.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetDigitalAttenuation': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDigitalAttenuation,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=datatypes__pb2.Double.SerializeToString,
            ),
            'SetDigitalAttenuation': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDigitalAttenuation,
                    request_deserializer=rfdc__pb2.IndexedDouble.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetOutputCurrent': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOutputCurrent,
                    request_deserializer=rfdc__pb2.ConverterIndex.FromString,
                    response_serializer=datatypes__pb2.Double.SerializeToString,
            ),
            'SetOutputCurrent': grpc.unary_unary_rpc_method_handler(
                    servicer.SetOutputCurrent,
                    request_deserializer=rfdc__pb2.IndexedDouble.FromString,
                    response_serializer=datatypes__pb2.Double.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'rfdc.RFdcService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('rfdc.RFdcService', rpc_method_handlers)


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

    @staticmethod
    def GetBlockStatus(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,
            '/rfdc.RFdcService/GetBlockStatus',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.BlockStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMixerFrequency(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,
            '/rfdc.RFdcService/GetMixerFrequency',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.Frequency.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetMixerFrequency(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,
            '/rfdc.RFdcService/SetMixerFrequency',
            rfdc__pb2.Frequency.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPhase(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,
            '/rfdc.RFdcService/GetPhase',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.Phase.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetPhase(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,
            '/rfdc.RFdcService/SetPhase',
            rfdc__pb2.Phase.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMixerMode(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,
            '/rfdc.RFdcService/GetMixerMode',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.Mode.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetMixerSettings(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,
            '/rfdc.RFdcService/SetMixerSettings',
            rfdc__pb2.MixerSettings.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDataType(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,
            '/rfdc.RFdcService/GetDataType',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.DataType.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInterpolation(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,
            '/rfdc.RFdcService/GetInterpolation',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.Interpolation.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetInterpolation(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,
            '/rfdc.RFdcService/SetInterpolation',
            rfdc__pb2.Interpolation.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDecimation(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,
            '/rfdc.RFdcService/GetDecimation',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.Decimation.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetDecimation(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,
            '/rfdc.RFdcService/SetDecimation',
            rfdc__pb2.Decimation.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInvSincFIR(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,
            '/rfdc.RFdcService/GetInvSincFIR',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.InvSincFIR.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetInvSincFIR(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,
            '/rfdc.RFdcService/SetInvSincFIR',
            rfdc__pb2.InvSincFIR.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetThresholdStickyClear(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,
            '/rfdc.RFdcService/SetThresholdStickyClear',
            rfdc__pb2.ThresholdToUpdate.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartUp(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,
            '/rfdc.RFdcService/StartUp',
            rfdc__pb2.TileIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Shutdown(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,
            '/rfdc.RFdcService/Shutdown',
            rfdc__pb2.TileIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Reset(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,
            '/rfdc.RFdcService/Reset',
            rfdc__pb2.TileIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InterruptClear(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,
            '/rfdc.RFdcService/InterruptClear',
            rfdc__pb2.ConverterIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInterruptStatus(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,
            '/rfdc.RFdcService/GetInterruptStatus',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.InterruptSettings.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetNyquistZone(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,
            '/rfdc.RFdcService/GetNyquistZone',
            rfdc__pb2.ConverterIndex.SerializeToString,
            rfdc__pb2.NyquistZone.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetNyquistZone(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,
            '/rfdc.RFdcService/SetNyquistZone',
            rfdc__pb2.NyquistZone.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportStatus(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,
            '/rfdc.RFdcService/ReportStatus',
            datatypes__pb2.Empty.SerializeToString,
            rfdc__pb2.StatusReport.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResetStatus(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,
            '/rfdc.RFdcService/ResetStatus',
            datatypes__pb2.Empty.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDigitalAttenuation(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,
            '/rfdc.RFdcService/GetDigitalAttenuation',
            rfdc__pb2.ConverterIndex.SerializeToString,
            datatypes__pb2.Double.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetDigitalAttenuation(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,
            '/rfdc.RFdcService/SetDigitalAttenuation',
            rfdc__pb2.IndexedDouble.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOutputCurrent(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,
            '/rfdc.RFdcService/GetOutputCurrent',
            rfdc__pb2.ConverterIndex.SerializeToString,
            datatypes__pb2.Double.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetOutputCurrent(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,
            '/rfdc.RFdcService/SetOutputCurrent',
            rfdc__pb2.IndexedDouble.SerializeToString,
            datatypes__pb2.Double.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
