# 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.pulsegen_pb2 as pulsegen__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 pulsegen_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 PulseGenServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetNCOFrequency = channel.unary_unary(
                '/pulsegen.PulseGenService/GetNCOFrequency',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=pulsegen__pb2.Frequency.FromString,
                _registered_method=True)
        self.SetNCOFrequency = channel.unary_unary(
                '/pulsegen.PulseGenService/SetNCOFrequency',
                request_serializer=pulsegen__pb2.Frequency.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.Reset = channel.unary_unary(
                '/pulsegen.PulseGenService/Reset',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.ResetEnvelopeMemory = channel.unary_unary(
                '/pulsegen.PulseGenService/ResetEnvelopeMemory',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetAmplitudeCalibration = channel.unary_unary(
                '/pulsegen.PulseGenService/GetAmplitudeCalibration',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=pulsegen__pb2.AmplitudeCalibration.FromString,
                _registered_method=True)
        self.SetAmplitudeCalibration = channel.unary_unary(
                '/pulsegen.PulseGenService/SetAmplitudeCalibration',
                request_serializer=pulsegen__pb2.AmplitudeCalibration.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetPhaseOffset = channel.unary_unary(
                '/pulsegen.PulseGenService/GetPhaseOffset',
                request_serializer=pulsegen__pb2.IndexSet.SerializeToString,
                response_deserializer=pulsegen__pb2.PhaseOffset.FromString,
                _registered_method=True)
        self.SetPhaseOffset = channel.unary_unary(
                '/pulsegen.PulseGenService/SetPhaseOffset',
                request_serializer=pulsegen__pb2.PhaseOffset.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetGlobalPhase = channel.unary_unary(
                '/pulsegen.PulseGenService/GetGlobalPhase',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=pulsegen__pb2.PhaseOffset.FromString,
                _registered_method=True)
        self.GetDuration = channel.unary_unary(
                '/pulsegen.PulseGenService/GetDuration',
                request_serializer=pulsegen__pb2.IndexSet.SerializeToString,
                response_deserializer=pulsegen__pb2.Duration.FromString,
                _registered_method=True)
        self.SetDuration = channel.unary_unary(
                '/pulsegen.PulseGenService/SetDuration',
                request_serializer=pulsegen__pb2.Duration.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetStartAddressI = channel.unary_unary(
                '/pulsegen.PulseGenService/GetStartAddressI',
                request_serializer=pulsegen__pb2.IndexSet.SerializeToString,
                response_deserializer=pulsegen__pb2.Address.FromString,
                _registered_method=True)
        self.SetStartAddressI = channel.unary_unary(
                '/pulsegen.PulseGenService/SetStartAddressI',
                request_serializer=pulsegen__pb2.Address.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetStartAddressQ = channel.unary_unary(
                '/pulsegen.PulseGenService/GetStartAddressQ',
                request_serializer=pulsegen__pb2.IndexSet.SerializeToString,
                response_deserializer=pulsegen__pb2.Address.FromString,
                _registered_method=True)
        self.SetStartAddressQ = channel.unary_unary(
                '/pulsegen.PulseGenService/SetStartAddressQ',
                request_serializer=pulsegen__pb2.Address.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.TriggerManually = channel.unary_unary(
                '/pulsegen.PulseGenService/TriggerManually',
                request_serializer=pulsegen__pb2.IndexSet.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.LoadPulse = channel.unary_unary(
                '/pulsegen.PulseGenService/LoadPulse',
                request_serializer=pulsegen__pb2.Pulse.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetStatusFlags = channel.unary_unary(
                '/pulsegen.PulseGenService/GetStatusFlags',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=pulsegen__pb2.StatusFlags.FromString,
                _registered_method=True)
        self.ResetStatusFlags = channel.unary_unary(
                '/pulsegen.PulseGenService/ResetStatusFlags',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)


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

    def GetNCOFrequency(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 SetNCOFrequency(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 ResetEnvelopeMemory(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 GetAmplitudeCalibration(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 SetAmplitudeCalibration(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 GetPhaseOffset(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 SetPhaseOffset(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 GetGlobalPhase(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 GetDuration(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 SetDuration(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 GetStartAddressI(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 SetStartAddressI(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 GetStartAddressQ(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 SetStartAddressQ(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 TriggerManually(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 LoadPulse(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 GetStatusFlags(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 ResetStatusFlags(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_PulseGenServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetNCOFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNCOFrequency,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=pulsegen__pb2.Frequency.SerializeToString,
            ),
            'SetNCOFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.SetNCOFrequency,
                    request_deserializer=pulsegen__pb2.Frequency.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'Reset': grpc.unary_unary_rpc_method_handler(
                    servicer.Reset,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'ResetEnvelopeMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetEnvelopeMemory,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetAmplitudeCalibration': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAmplitudeCalibration,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=pulsegen__pb2.AmplitudeCalibration.SerializeToString,
            ),
            'SetAmplitudeCalibration': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAmplitudeCalibration,
                    request_deserializer=pulsegen__pb2.AmplitudeCalibration.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetPhaseOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPhaseOffset,
                    request_deserializer=pulsegen__pb2.IndexSet.FromString,
                    response_serializer=pulsegen__pb2.PhaseOffset.SerializeToString,
            ),
            'SetPhaseOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPhaseOffset,
                    request_deserializer=pulsegen__pb2.PhaseOffset.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetGlobalPhase': grpc.unary_unary_rpc_method_handler(
                    servicer.GetGlobalPhase,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=pulsegen__pb2.PhaseOffset.SerializeToString,
            ),
            'GetDuration': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDuration,
                    request_deserializer=pulsegen__pb2.IndexSet.FromString,
                    response_serializer=pulsegen__pb2.Duration.SerializeToString,
            ),
            'SetDuration': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDuration,
                    request_deserializer=pulsegen__pb2.Duration.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetStartAddressI': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStartAddressI,
                    request_deserializer=pulsegen__pb2.IndexSet.FromString,
                    response_serializer=pulsegen__pb2.Address.SerializeToString,
            ),
            'SetStartAddressI': grpc.unary_unary_rpc_method_handler(
                    servicer.SetStartAddressI,
                    request_deserializer=pulsegen__pb2.Address.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetStartAddressQ': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStartAddressQ,
                    request_deserializer=pulsegen__pb2.IndexSet.FromString,
                    response_serializer=pulsegen__pb2.Address.SerializeToString,
            ),
            'SetStartAddressQ': grpc.unary_unary_rpc_method_handler(
                    servicer.SetStartAddressQ,
                    request_deserializer=pulsegen__pb2.Address.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'TriggerManually': grpc.unary_unary_rpc_method_handler(
                    servicer.TriggerManually,
                    request_deserializer=pulsegen__pb2.IndexSet.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'LoadPulse': grpc.unary_unary_rpc_method_handler(
                    servicer.LoadPulse,
                    request_deserializer=pulsegen__pb2.Pulse.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetStatusFlags': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStatusFlags,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=pulsegen__pb2.StatusFlags.SerializeToString,
            ),
            'ResetStatusFlags': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetStatusFlags,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'pulsegen.PulseGenService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('pulsegen.PulseGenService', rpc_method_handlers)


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

    @staticmethod
    def GetNCOFrequency(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,
            '/pulsegen.PulseGenService/GetNCOFrequency',
            datatypes__pb2.EndpointIndex.SerializeToString,
            pulsegen__pb2.Frequency.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetNCOFrequency(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,
            '/pulsegen.PulseGenService/SetNCOFrequency',
            pulsegen__pb2.Frequency.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,
            '/pulsegen.PulseGenService/Reset',
            datatypes__pb2.EndpointIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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

    @staticmethod
    def GetAmplitudeCalibration(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,
            '/pulsegen.PulseGenService/GetAmplitudeCalibration',
            datatypes__pb2.EndpointIndex.SerializeToString,
            pulsegen__pb2.AmplitudeCalibration.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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

    @staticmethod
    def GetPhaseOffset(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,
            '/pulsegen.PulseGenService/GetPhaseOffset',
            pulsegen__pb2.IndexSet.SerializeToString,
            pulsegen__pb2.PhaseOffset.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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

    @staticmethod
    def GetGlobalPhase(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,
            '/pulsegen.PulseGenService/GetGlobalPhase',
            datatypes__pb2.EndpointIndex.SerializeToString,
            pulsegen__pb2.PhaseOffset.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDuration(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,
            '/pulsegen.PulseGenService/GetDuration',
            pulsegen__pb2.IndexSet.SerializeToString,
            pulsegen__pb2.Duration.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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

    @staticmethod
    def GetStartAddressI(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,
            '/pulsegen.PulseGenService/GetStartAddressI',
            pulsegen__pb2.IndexSet.SerializeToString,
            pulsegen__pb2.Address.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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

    @staticmethod
    def GetStartAddressQ(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,
            '/pulsegen.PulseGenService/GetStartAddressQ',
            pulsegen__pb2.IndexSet.SerializeToString,
            pulsegen__pb2.Address.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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

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

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

    @staticmethod
    def GetStatusFlags(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,
            '/pulsegen.PulseGenService/GetStatusFlags',
            datatypes__pb2.EndpointIndex.SerializeToString,
            pulsegen__pb2.StatusFlags.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

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