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

from . import allegoserver_pb2 as allegoserver__pb2
from . import biointerface_pb2 as biointerface__pb2
from . import common_pb2 as common__pb2
from . import datasource_pb2 as datasource__pb2
from . import spikesorter_pb2 as spikesorter__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Healthcheck = channel.unary_unary(
                '/allego.AllegoCore/Healthcheck',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.Restart = channel.unary_unary(
                '/allego.AllegoCore/Restart',
                request_serializer=allegoserver__pb2.RestartRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.Close = channel.unary_unary(
                '/allego.AllegoCore/Close',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetRadixEnvironment = channel.unary_unary(
                '/allego.AllegoCore/GetRadixEnvironment',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.RadixEnvironment.FromString,
                )
        self.WorkspaceControl = channel.unary_unary(
                '/allego.AllegoCore/WorkspaceControl',
                request_serializer=common__pb2.WorkspaceControlRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetRadiensServers = channel.unary_unary(
                '/allego.AllegoCore/GetRadiensServers',
                request_serializer=common__pb2.GetRadiensServersRequest.SerializeToString,
                response_deserializer=common__pb2.RadiensServersReply.FromString,
                )
        self.SetConfigCore = channel.unary_unary(
                '/allego.AllegoCore/SetConfigCore',
                request_serializer=allegoserver__pb2.SetConfigCoreRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetProfileState = channel.unary_unary(
                '/allego.AllegoCore/SetProfileState',
                request_serializer=allegoserver__pb2.SetProfileRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetConfigRecording = channel.unary_unary(
                '/allego.AllegoCore/SetConfigRecording',
                request_serializer=allegoserver__pb2.ConfigRecording.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetStreamState = channel.unary_unary(
                '/allego.AllegoCore/SetStreamState',
                request_serializer=allegoserver__pb2.SetStreamRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetRecordState = channel.unary_unary(
                '/allego.AllegoCore/SetRecordState',
                request_serializer=allegoserver__pb2.SetRecordRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDIOEvents = channel.unary_unary(
                '/allego.AllegoCore/SetDIOEvents',
                request_serializer=allegoserver__pb2.DIOModeEventsRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDIOManual = channel.unary_unary(
                '/allego.AllegoCore/SetDIOManual',
                request_serializer=allegoserver__pb2.DIOModeManualRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDIOGated = channel.unary_unary(
                '/allego.AllegoCore/SetDIOGated',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDACGain = channel.unary_unary(
                '/allego.AllegoCore/SetDACGain',
                request_serializer=allegoserver__pb2.DACGainRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDACStream = channel.unary_unary(
                '/allego.AllegoCore/SetDACStream',
                request_serializer=common__pb2.DACStreamRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDACOff = channel.unary_unary(
                '/allego.AllegoCore/SetDACOff',
                request_serializer=allegoserver__pb2.DACOffRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetSimPorts = channel.unary_unary(
                '/allego.AllegoCore/SetSimPorts',
                request_serializer=allegoserver__pb2.SetSimPortsRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetMuxChannel = channel.unary_unary(
                '/allego.AllegoCore/SetMuxChannel',
                request_serializer=allegoserver__pb2.SetMuxChannelRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetTriggerMode = channel.unary_unary(
                '/allego.AllegoCore/SetTriggerMode',
                request_serializer=allegoserver__pb2.TriggerModeState.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetPotVoltage = channel.unary_unary(
                '/allego.AllegoCore/SetPotVoltage',
                request_serializer=allegoserver__pb2.SetPotVoltageRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetPotRange = channel.unary_unary(
                '/allego.AllegoCore/SetPotRange',
                request_serializer=allegoserver__pb2.SetPotRangeRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetPotMode = channel.unary_unary(
                '/allego.AllegoCore/SetPotMode',
                request_serializer=allegoserver__pb2.SetPotModeRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetPotCellEnable = channel.unary_unary(
                '/allego.AllegoCore/SetPotCellEnable',
                request_serializer=allegoserver__pb2.SetPotCellEnableRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetDSPGroup = channel.unary_unary(
                '/allego.AllegoCore/SetDSPGroup',
                request_serializer=common__pb2.SetDSPGroupRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetConfig = channel.unary_unary(
                '/allego.AllegoCore/GetConfig',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.ConfigCore.FromString,
                )
        self.GetWorkspace = channel.unary_unary(
                '/allego.AllegoCore/GetWorkspace',
                request_serializer=common__pb2.GetWorkspaceRequest.SerializeToString,
                response_deserializer=common__pb2.GetWorkspaceReply.FromString,
                )
        self.GetConfigRecording = channel.unary_unary(
                '/allego.AllegoCore/GetConfigRecording',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.ConfigRecording.FromString,
                )
        self.GetStatus = channel.unary_unary(
                '/allego.AllegoCore/GetStatus',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.BackboneStatus.FromString,
                )
        self.GetConfigAndStatus = channel.unary_unary(
                '/allego.AllegoCore/GetConfigAndStatus',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.ConfigAndStatus.FromString,
                )
        self.GetDataSourceParams = channel.unary_unary(
                '/allego.AllegoCore/GetDataSourceParams',
                request_serializer=common__pb2.SignalGroupIDRequest.SerializeToString,
                response_deserializer=datasource__pb2.DataSourceParams.FromString,
                )
        self.GetIntanImpedance = channel.unary_unary(
                '/allego.AllegoCore/GetIntanImpedance',
                request_serializer=datasource__pb2.ImpedanceRequest.SerializeToString,
                response_deserializer=datasource__pb2.Impedance.FromString,
                )
        self.GetDSPGroup = channel.unary_unary(
                '/allego.AllegoCore/GetDSPGroup',
                request_serializer=common__pb2.SignalGroupIDRequest.SerializeToString,
                response_deserializer=common__pb2.DSPGroup.FromString,
                )
        self.GetDIOReg = channel.unary_unary(
                '/allego.AllegoCore/GetDIOReg',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.DigitalOutRegister.FromString,
                )
        self.GetDACReg = channel.unary_unary(
                '/allego.AllegoCore/GetDACReg',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.AnalogOutRegister.FromString,
                )
        self.GetSerial = channel.unary_unary(
                '/allego.AllegoCore/GetSerial',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.SerialNumber.FromString,
                )
        self.GetTriggerMode = channel.unary_unary(
                '/allego.AllegoCore/GetTriggerMode',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.TriggerModeState.FromString,
                )
        self.GetADCLevel = channel.unary_unary(
                '/allego.AllegoCore/GetADCLevel',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.GetADCLevelReply.FromString,
                )
        self.ListSensorSpecs = channel.unary_unary(
                '/allego.AllegoCore/ListSensorSpecs',
                request_serializer=common__pb2.SignalGroupIDRequest.SerializeToString,
                response_deserializer=common__pb2.ListSensorSpecsReply.FromString,
                )
        self.GetSignalGroupIDs = channel.unary_unary(
                '/allego.AllegoCore/GetSignalGroupIDs',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.GetSignalGroupIDsReply.FromString,
                )
        self.GetSignalGroup = channel.unary_unary(
                '/allego.AllegoCore/GetSignalGroup',
                request_serializer=common__pb2.SignalGroupIDRequest.SerializeToString,
                response_deserializer=common__pb2.SignalGroup.FromString,
                )
        self.UpdateSignalGroup = channel.unary_unary(
                '/allego.AllegoCore/UpdateSignalGroup',
                request_serializer=common__pb2.UpdateSignalGroupRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.ScanPorts = channel.unary_unary(
                '/allego.AllegoCore/ScanPorts',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.SignalGroup.FromString,
                )
        self.SetSensor = channel.unary_unary(
                '/allego.AllegoCore/SetSensor',
                request_serializer=common__pb2.SetSensorRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetSensorPositionTcs = channel.unary_unary(
                '/allego.AllegoCore/SetSensorPositionTcs',
                request_serializer=common__pb2.SetSensorPositionTcsRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SetSitePositionsTcs = channel.unary_unary(
                '/allego.AllegoCore/SetSitePositionsTcs',
                request_serializer=common__pb2.SetSitePositionsTcsRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetDataSourceStatus = channel.unary_unary(
                '/allego.AllegoCore/GetDataSourceStatus',
                request_serializer=common__pb2.SignalGroupIDRequest.SerializeToString,
                response_deserializer=datasource__pb2.DataSourceStatus.FromString,
                )
        self.FeatureStart = channel.unary_unary(
                '/allego.AllegoCore/FeatureStart',
                request_serializer=common__pb2.FeatureStartStopRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.FeatureStop = channel.unary_unary(
                '/allego.AllegoCore/FeatureStop',
                request_serializer=common__pb2.FeatureStartStopRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetPrivacy = channel.unary_unary(
                '/allego.AllegoCore/GetPrivacy',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.PrivacyReply.FromString,
                )
        self.SetPrivacy = channel.unary_unary(
                '/allego.AllegoCore/SetPrivacy',
                request_serializer=common__pb2.SetPrivacyRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetOrCreateEventViewer = channel.unary_unary(
                '/allego.AllegoCore/GetOrCreateEventViewer',
                request_serializer=common__pb2.EventViewerID.SerializeToString,
                response_deserializer=common__pb2.EventViewerConfig.FromString,
                )
        self.UpdateEventViewer = channel.unary_unary(
                '/allego.AllegoCore/UpdateEventViewer',
                request_serializer=common__pb2.EventViewerConfig.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.ListEventViewerEvents = channel.unary_unary(
                '/allego.AllegoCore/ListEventViewerEvents',
                request_serializer=common__pb2.EventViewerID.SerializeToString,
                response_deserializer=common__pb2.ListEventViewerEventsReply.FromString,
                )
        self.GetEventViewerEvent = channel.unary_unary(
                '/allego.AllegoCore/GetEventViewerEvent',
                request_serializer=common__pb2.GetEventViewerEventRequest.SerializeToString,
                response_deserializer=common__pb2.EventViewerEvent.FromString,
                )
        self.ListEventViewers = channel.unary_unary(
                '/allego.AllegoCore/ListEventViewers',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.ListEventViewersReply.FromString,
                )
        self.GetHALdashboard = channel.unary_unary(
                '/allego.AllegoCore/GetHALdashboard',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=allegoserver__pb2.HALdashboard.FromString,
                )


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

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

    def Restart(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 Close(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 GetRadixEnvironment(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 WorkspaceControl(self, request, context):
        """rpc LogSystemInfo (LogSystemRequest) returns (StandardReply) {}
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetRadiensServers(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 SetConfigCore(self, request, context):
        """Setters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetProfileState(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 SetConfigRecording(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 SetStreamState(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 SetRecordState(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 SetDIOEvents(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 SetDIOManual(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 SetDIOGated(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 SetDACGain(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 SetDACStream(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 SetDACOff(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 SetSimPorts(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 SetMuxChannel(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 SetTriggerMode(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 SetPotVoltage(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 SetPotRange(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 SetPotMode(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 SetPotCellEnable(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 SetDSPGroup(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 GetConfig(self, request, context):
        """Getters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWorkspace(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 GetConfigRecording(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 GetStatus(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 GetConfigAndStatus(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 GetDataSourceParams(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 GetIntanImpedance(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 GetDSPGroup(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 GetDIOReg(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 GetDACReg(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 GetSerial(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 GetTriggerMode(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 GetADCLevel(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 ListSensorSpecs(self, request, context):
        """Selection Groups and Sensors
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSignalGroupIDs(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 GetSignalGroup(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 UpdateSignalGroup(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 ScanPorts(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 SetSensor(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 SetSensorPositionTcs(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 SetSitePositionsTcs(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 GetDataSourceStatus(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 FeatureStart(self, request, context):
        """Licensing and analytics
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FeatureStop(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 GetPrivacy(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 SetPrivacy(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 GetOrCreateEventViewer(self, request, context):
        """EventViewer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateEventViewer(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 ListEventViewerEvents(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 GetEventViewerEvent(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 ListEventViewers(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 GetHALdashboard(self, request, context):
        """HAL
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_AllegoCoreServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Healthcheck': grpc.unary_unary_rpc_method_handler(
                    servicer.Healthcheck,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'Restart': grpc.unary_unary_rpc_method_handler(
                    servicer.Restart,
                    request_deserializer=allegoserver__pb2.RestartRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'Close': grpc.unary_unary_rpc_method_handler(
                    servicer.Close,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetRadixEnvironment': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRadixEnvironment,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.RadixEnvironment.SerializeToString,
            ),
            'WorkspaceControl': grpc.unary_unary_rpc_method_handler(
                    servicer.WorkspaceControl,
                    request_deserializer=common__pb2.WorkspaceControlRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetRadiensServers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRadiensServers,
                    request_deserializer=common__pb2.GetRadiensServersRequest.FromString,
                    response_serializer=common__pb2.RadiensServersReply.SerializeToString,
            ),
            'SetConfigCore': grpc.unary_unary_rpc_method_handler(
                    servicer.SetConfigCore,
                    request_deserializer=allegoserver__pb2.SetConfigCoreRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetProfileState': grpc.unary_unary_rpc_method_handler(
                    servicer.SetProfileState,
                    request_deserializer=allegoserver__pb2.SetProfileRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetConfigRecording': grpc.unary_unary_rpc_method_handler(
                    servicer.SetConfigRecording,
                    request_deserializer=allegoserver__pb2.ConfigRecording.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetStreamState': grpc.unary_unary_rpc_method_handler(
                    servicer.SetStreamState,
                    request_deserializer=allegoserver__pb2.SetStreamRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetRecordState': grpc.unary_unary_rpc_method_handler(
                    servicer.SetRecordState,
                    request_deserializer=allegoserver__pb2.SetRecordRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDIOEvents': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDIOEvents,
                    request_deserializer=allegoserver__pb2.DIOModeEventsRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDIOManual': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDIOManual,
                    request_deserializer=allegoserver__pb2.DIOModeManualRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDIOGated': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDIOGated,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDACGain': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDACGain,
                    request_deserializer=allegoserver__pb2.DACGainRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDACStream': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDACStream,
                    request_deserializer=common__pb2.DACStreamRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDACOff': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDACOff,
                    request_deserializer=allegoserver__pb2.DACOffRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetSimPorts': grpc.unary_unary_rpc_method_handler(
                    servicer.SetSimPorts,
                    request_deserializer=allegoserver__pb2.SetSimPortsRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetMuxChannel': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMuxChannel,
                    request_deserializer=allegoserver__pb2.SetMuxChannelRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetTriggerMode': grpc.unary_unary_rpc_method_handler(
                    servicer.SetTriggerMode,
                    request_deserializer=allegoserver__pb2.TriggerModeState.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetPotVoltage': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPotVoltage,
                    request_deserializer=allegoserver__pb2.SetPotVoltageRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetPotRange': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPotRange,
                    request_deserializer=allegoserver__pb2.SetPotRangeRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetPotMode': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPotMode,
                    request_deserializer=allegoserver__pb2.SetPotModeRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetPotCellEnable': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPotCellEnable,
                    request_deserializer=allegoserver__pb2.SetPotCellEnableRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetDSPGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDSPGroup,
                    request_deserializer=common__pb2.SetDSPGroupRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.ConfigCore.SerializeToString,
            ),
            'GetWorkspace': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWorkspace,
                    request_deserializer=common__pb2.GetWorkspaceRequest.FromString,
                    response_serializer=common__pb2.GetWorkspaceReply.SerializeToString,
            ),
            'GetConfigRecording': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfigRecording,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.ConfigRecording.SerializeToString,
            ),
            'GetStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStatus,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.BackboneStatus.SerializeToString,
            ),
            'GetConfigAndStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfigAndStatus,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.ConfigAndStatus.SerializeToString,
            ),
            'GetDataSourceParams': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDataSourceParams,
                    request_deserializer=common__pb2.SignalGroupIDRequest.FromString,
                    response_serializer=datasource__pb2.DataSourceParams.SerializeToString,
            ),
            'GetIntanImpedance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetIntanImpedance,
                    request_deserializer=datasource__pb2.ImpedanceRequest.FromString,
                    response_serializer=datasource__pb2.Impedance.SerializeToString,
            ),
            'GetDSPGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDSPGroup,
                    request_deserializer=common__pb2.SignalGroupIDRequest.FromString,
                    response_serializer=common__pb2.DSPGroup.SerializeToString,
            ),
            'GetDIOReg': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDIOReg,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.DigitalOutRegister.SerializeToString,
            ),
            'GetDACReg': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDACReg,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.AnalogOutRegister.SerializeToString,
            ),
            'GetSerial': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSerial,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.SerialNumber.SerializeToString,
            ),
            'GetTriggerMode': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTriggerMode,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.TriggerModeState.SerializeToString,
            ),
            'GetADCLevel': grpc.unary_unary_rpc_method_handler(
                    servicer.GetADCLevel,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.GetADCLevelReply.SerializeToString,
            ),
            'ListSensorSpecs': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSensorSpecs,
                    request_deserializer=common__pb2.SignalGroupIDRequest.FromString,
                    response_serializer=common__pb2.ListSensorSpecsReply.SerializeToString,
            ),
            'GetSignalGroupIDs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSignalGroupIDs,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.GetSignalGroupIDsReply.SerializeToString,
            ),
            'GetSignalGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSignalGroup,
                    request_deserializer=common__pb2.SignalGroupIDRequest.FromString,
                    response_serializer=common__pb2.SignalGroup.SerializeToString,
            ),
            'UpdateSignalGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateSignalGroup,
                    request_deserializer=common__pb2.UpdateSignalGroupRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'ScanPorts': grpc.unary_unary_rpc_method_handler(
                    servicer.ScanPorts,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.SignalGroup.SerializeToString,
            ),
            'SetSensor': grpc.unary_unary_rpc_method_handler(
                    servicer.SetSensor,
                    request_deserializer=common__pb2.SetSensorRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetSensorPositionTcs': grpc.unary_unary_rpc_method_handler(
                    servicer.SetSensorPositionTcs,
                    request_deserializer=common__pb2.SetSensorPositionTcsRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SetSitePositionsTcs': grpc.unary_unary_rpc_method_handler(
                    servicer.SetSitePositionsTcs,
                    request_deserializer=common__pb2.SetSitePositionsTcsRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetDataSourceStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDataSourceStatus,
                    request_deserializer=common__pb2.SignalGroupIDRequest.FromString,
                    response_serializer=datasource__pb2.DataSourceStatus.SerializeToString,
            ),
            'FeatureStart': grpc.unary_unary_rpc_method_handler(
                    servicer.FeatureStart,
                    request_deserializer=common__pb2.FeatureStartStopRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'FeatureStop': grpc.unary_unary_rpc_method_handler(
                    servicer.FeatureStop,
                    request_deserializer=common__pb2.FeatureStartStopRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetPrivacy': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPrivacy,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.PrivacyReply.SerializeToString,
            ),
            'SetPrivacy': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPrivacy,
                    request_deserializer=common__pb2.SetPrivacyRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetOrCreateEventViewer': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOrCreateEventViewer,
                    request_deserializer=common__pb2.EventViewerID.FromString,
                    response_serializer=common__pb2.EventViewerConfig.SerializeToString,
            ),
            'UpdateEventViewer': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateEventViewer,
                    request_deserializer=common__pb2.EventViewerConfig.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'ListEventViewerEvents': grpc.unary_unary_rpc_method_handler(
                    servicer.ListEventViewerEvents,
                    request_deserializer=common__pb2.EventViewerID.FromString,
                    response_serializer=common__pb2.ListEventViewerEventsReply.SerializeToString,
            ),
            'GetEventViewerEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEventViewerEvent,
                    request_deserializer=common__pb2.GetEventViewerEventRequest.FromString,
                    response_serializer=common__pb2.EventViewerEvent.SerializeToString,
            ),
            'ListEventViewers': grpc.unary_unary_rpc_method_handler(
                    servicer.ListEventViewers,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.ListEventViewersReply.SerializeToString,
            ),
            'GetHALdashboard': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHALdashboard,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=allegoserver__pb2.HALdashboard.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'allego.AllegoCore', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def Healthcheck(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, '/allego.AllegoCore/Healthcheck',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Restart(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, '/allego.AllegoCore/Restart',
            allegoserver__pb2.RestartRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Close(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, '/allego.AllegoCore/Close',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetRadixEnvironment(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, '/allego.AllegoCore/GetRadixEnvironment',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.RadixEnvironment.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WorkspaceControl(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, '/allego.AllegoCore/WorkspaceControl',
            common__pb2.WorkspaceControlRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetRadiensServers(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, '/allego.AllegoCore/GetRadiensServers',
            common__pb2.GetRadiensServersRequest.SerializeToString,
            common__pb2.RadiensServersReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetConfigCore(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, '/allego.AllegoCore/SetConfigCore',
            allegoserver__pb2.SetConfigCoreRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetProfileState(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, '/allego.AllegoCore/SetProfileState',
            allegoserver__pb2.SetProfileRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetConfigRecording(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, '/allego.AllegoCore/SetConfigRecording',
            allegoserver__pb2.ConfigRecording.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetStreamState(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, '/allego.AllegoCore/SetStreamState',
            allegoserver__pb2.SetStreamRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetRecordState(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, '/allego.AllegoCore/SetRecordState',
            allegoserver__pb2.SetRecordRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDIOEvents(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, '/allego.AllegoCore/SetDIOEvents',
            allegoserver__pb2.DIOModeEventsRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDIOManual(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, '/allego.AllegoCore/SetDIOManual',
            allegoserver__pb2.DIOModeManualRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDIOGated(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, '/allego.AllegoCore/SetDIOGated',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDACGain(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, '/allego.AllegoCore/SetDACGain',
            allegoserver__pb2.DACGainRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDACStream(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, '/allego.AllegoCore/SetDACStream',
            common__pb2.DACStreamRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDACOff(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, '/allego.AllegoCore/SetDACOff',
            allegoserver__pb2.DACOffRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetSimPorts(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, '/allego.AllegoCore/SetSimPorts',
            allegoserver__pb2.SetSimPortsRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetMuxChannel(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, '/allego.AllegoCore/SetMuxChannel',
            allegoserver__pb2.SetMuxChannelRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetTriggerMode(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, '/allego.AllegoCore/SetTriggerMode',
            allegoserver__pb2.TriggerModeState.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetPotVoltage(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, '/allego.AllegoCore/SetPotVoltage',
            allegoserver__pb2.SetPotVoltageRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetPotRange(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, '/allego.AllegoCore/SetPotRange',
            allegoserver__pb2.SetPotRangeRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetPotMode(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, '/allego.AllegoCore/SetPotMode',
            allegoserver__pb2.SetPotModeRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetPotCellEnable(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, '/allego.AllegoCore/SetPotCellEnable',
            allegoserver__pb2.SetPotCellEnableRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetDSPGroup(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, '/allego.AllegoCore/SetDSPGroup',
            common__pb2.SetDSPGroupRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetConfig(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, '/allego.AllegoCore/GetConfig',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.ConfigCore.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWorkspace(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, '/allego.AllegoCore/GetWorkspace',
            common__pb2.GetWorkspaceRequest.SerializeToString,
            common__pb2.GetWorkspaceReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetConfigRecording(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, '/allego.AllegoCore/GetConfigRecording',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.ConfigRecording.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetStatus(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, '/allego.AllegoCore/GetStatus',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.BackboneStatus.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetConfigAndStatus(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, '/allego.AllegoCore/GetConfigAndStatus',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.ConfigAndStatus.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDataSourceParams(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, '/allego.AllegoCore/GetDataSourceParams',
            common__pb2.SignalGroupIDRequest.SerializeToString,
            datasource__pb2.DataSourceParams.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetIntanImpedance(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, '/allego.AllegoCore/GetIntanImpedance',
            datasource__pb2.ImpedanceRequest.SerializeToString,
            datasource__pb2.Impedance.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDSPGroup(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, '/allego.AllegoCore/GetDSPGroup',
            common__pb2.SignalGroupIDRequest.SerializeToString,
            common__pb2.DSPGroup.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDIOReg(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, '/allego.AllegoCore/GetDIOReg',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.DigitalOutRegister.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDACReg(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, '/allego.AllegoCore/GetDACReg',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.AnalogOutRegister.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSerial(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, '/allego.AllegoCore/GetSerial',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.SerialNumber.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetTriggerMode(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, '/allego.AllegoCore/GetTriggerMode',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.TriggerModeState.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetADCLevel(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, '/allego.AllegoCore/GetADCLevel',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.GetADCLevelReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListSensorSpecs(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, '/allego.AllegoCore/ListSensorSpecs',
            common__pb2.SignalGroupIDRequest.SerializeToString,
            common__pb2.ListSensorSpecsReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSignalGroupIDs(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, '/allego.AllegoCore/GetSignalGroupIDs',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.GetSignalGroupIDsReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSignalGroup(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, '/allego.AllegoCore/GetSignalGroup',
            common__pb2.SignalGroupIDRequest.SerializeToString,
            common__pb2.SignalGroup.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateSignalGroup(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, '/allego.AllegoCore/UpdateSignalGroup',
            common__pb2.UpdateSignalGroupRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ScanPorts(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, '/allego.AllegoCore/ScanPorts',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.SignalGroup.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetSensor(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, '/allego.AllegoCore/SetSensor',
            common__pb2.SetSensorRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetSensorPositionTcs(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, '/allego.AllegoCore/SetSensorPositionTcs',
            common__pb2.SetSensorPositionTcsRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetSitePositionsTcs(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, '/allego.AllegoCore/SetSitePositionsTcs',
            common__pb2.SetSitePositionsTcsRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDataSourceStatus(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, '/allego.AllegoCore/GetDataSourceStatus',
            common__pb2.SignalGroupIDRequest.SerializeToString,
            datasource__pb2.DataSourceStatus.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FeatureStart(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, '/allego.AllegoCore/FeatureStart',
            common__pb2.FeatureStartStopRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FeatureStop(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, '/allego.AllegoCore/FeatureStop',
            common__pb2.FeatureStartStopRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetPrivacy(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, '/allego.AllegoCore/GetPrivacy',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.PrivacyReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetPrivacy(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, '/allego.AllegoCore/SetPrivacy',
            common__pb2.SetPrivacyRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetOrCreateEventViewer(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, '/allego.AllegoCore/GetOrCreateEventViewer',
            common__pb2.EventViewerID.SerializeToString,
            common__pb2.EventViewerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateEventViewer(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, '/allego.AllegoCore/UpdateEventViewer',
            common__pb2.EventViewerConfig.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListEventViewerEvents(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, '/allego.AllegoCore/ListEventViewerEvents',
            common__pb2.EventViewerID.SerializeToString,
            common__pb2.ListEventViewerEventsReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetEventViewerEvent(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, '/allego.AllegoCore/GetEventViewerEvent',
            common__pb2.GetEventViewerEventRequest.SerializeToString,
            common__pb2.EventViewerEvent.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListEventViewers(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, '/allego.AllegoCore/ListEventViewers',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.ListEventViewersReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetHALdashboard(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, '/allego.AllegoCore/GetHALdashboard',
            common__pb2.StandardRequest.SerializeToString,
            allegoserver__pb2.HALdashboard.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class Pcache1Stub(object):
    """The Pcache1 service definition.
    This is interface for getting data from the primary cache
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Healthcheck = channel.unary_unary(
                '/allego.Pcache1/Healthcheck',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.GetHDSnapshot = channel.unary_unary(
                '/allego.Pcache1/GetHDSnapshot',
                request_serializer=common__pb2.HDSnapshotRequest.SerializeToString,
                response_deserializer=common__pb2.HDSnapshot.FromString,
                )
        self.GetHDSnapshotFromHead = channel.unary_unary(
                '/allego.Pcache1/GetHDSnapshotFromHead',
                request_serializer=common__pb2.HDSnapshotRequest.SerializeToString,
                response_deserializer=common__pb2.HDSnapshot.FromString,
                )
        self.GetSignals = channel.unary_unary(
                '/allego.Pcache1/GetSignals',
                request_serializer=common__pb2.GetSignalsRequest.SerializeToString,
                response_deserializer=common__pb2.RawSignals.FromString,
                )
        self.SetTimeRangeToHead = channel.unary_unary(
                '/allego.Pcache1/SetTimeRangeToHead',
                request_serializer=common__pb2.SignalGroupIDRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )


class Pcache1Servicer(object):
    """The Pcache1 service definition.
    This is interface for getting data from the primary cache
    """

    def Healthcheck(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 GetHDSnapshot(self, request, context):
        """rpc GetPCacheStatus(StandardRequest) returns (StandardReply) {}
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetHDSnapshotFromHead(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 GetSignals(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 SetTimeRangeToHead(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_Pcache1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Healthcheck': grpc.unary_unary_rpc_method_handler(
                    servicer.Healthcheck,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetHDSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHDSnapshot,
                    request_deserializer=common__pb2.HDSnapshotRequest.FromString,
                    response_serializer=common__pb2.HDSnapshot.SerializeToString,
            ),
            'GetHDSnapshotFromHead': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHDSnapshotFromHead,
                    request_deserializer=common__pb2.HDSnapshotRequest.FromString,
                    response_serializer=common__pb2.HDSnapshot.SerializeToString,
            ),
            'GetSignals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSignals,
                    request_deserializer=common__pb2.GetSignalsRequest.FromString,
                    response_serializer=common__pb2.RawSignals.SerializeToString,
            ),
            'SetTimeRangeToHead': grpc.unary_unary_rpc_method_handler(
                    servicer.SetTimeRangeToHead,
                    request_deserializer=common__pb2.SignalGroupIDRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'allego.Pcache1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class Pcache1(object):
    """The Pcache1 service definition.
    This is interface for getting data from the primary cache
    """

    @staticmethod
    def Healthcheck(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, '/allego.Pcache1/Healthcheck',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetHDSnapshot(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, '/allego.Pcache1/GetHDSnapshot',
            common__pb2.HDSnapshotRequest.SerializeToString,
            common__pb2.HDSnapshot.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetHDSnapshotFromHead(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, '/allego.Pcache1/GetHDSnapshotFromHead',
            common__pb2.HDSnapshotRequest.SerializeToString,
            common__pb2.HDSnapshot.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSignals(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, '/allego.Pcache1/GetSignals',
            common__pb2.GetSignalsRequest.SerializeToString,
            common__pb2.RawSignals.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetTimeRangeToHead(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, '/allego.Pcache1/SetTimeRangeToHead',
            common__pb2.SignalGroupIDRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class Kpi1Stub(object):
    """The Kpi1 service definition.
    This is interface for getting data from the KPI stream service
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Healthcheck = channel.unary_unary(
                '/allego.Kpi1/Healthcheck',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.KpiGetMetrics = channel.unary_unary(
                '/allego.Kpi1/KpiGetMetrics',
                request_serializer=common__pb2.KpiMetricsReq.SerializeToString,
                response_deserializer=common__pb2.KpiBundlePacketMetrics.FromString,
                )
        self.GetKpiStatus = channel.unary_unary(
                '/allego.Kpi1/GetKpiStatus',
                request_serializer=common__pb2.GetKpiStatusRequest.SerializeToString,
                response_deserializer=common__pb2.KpiStatusReply.FromString,
                )


class Kpi1Servicer(object):
    """The Kpi1 service definition.
    This is interface for getting data from the KPI stream service
    """

    def Healthcheck(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 KpiGetMetrics(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 GetKpiStatus(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_Kpi1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Healthcheck': grpc.unary_unary_rpc_method_handler(
                    servicer.Healthcheck,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'KpiGetMetrics': grpc.unary_unary_rpc_method_handler(
                    servicer.KpiGetMetrics,
                    request_deserializer=common__pb2.KpiMetricsReq.FromString,
                    response_serializer=common__pb2.KpiBundlePacketMetrics.SerializeToString,
            ),
            'GetKpiStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetKpiStatus,
                    request_deserializer=common__pb2.GetKpiStatusRequest.FromString,
                    response_serializer=common__pb2.KpiStatusReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'allego.Kpi1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class Kpi1(object):
    """The Kpi1 service definition.
    This is interface for getting data from the KPI stream service
    """

    @staticmethod
    def Healthcheck(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, '/allego.Kpi1/Healthcheck',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def KpiGetMetrics(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, '/allego.Kpi1/KpiGetMetrics',
            common__pb2.KpiMetricsReq.SerializeToString,
            common__pb2.KpiBundlePacketMetrics.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetKpiStatus(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, '/allego.Kpi1/GetKpiStatus',
            common__pb2.GetKpiStatusRequest.SerializeToString,
            common__pb2.KpiStatusReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Healthcheck = channel.unary_unary(
                '/allego.Neurons1/Healthcheck',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SpikeSorterCommand = channel.unary_unary(
                '/allego.Neurons1/SpikeSorterCommand',
                request_serializer=spikesorter__pb2.SpikeSorterCommandRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SpikeSorterSetParam = channel.unary_unary(
                '/allego.Neurons1/SpikeSorterSetParam',
                request_serializer=common__pb2.SpikeSorterSetParamRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SpikeSorterGetParam = channel.unary_unary(
                '/allego.Neurons1/SpikeSorterGetParam',
                request_serializer=spikesorter__pb2.SpikeSorterStandardRequest.SerializeToString,
                response_deserializer=spikesorter__pb2.GetSpikeSorterParamCommandReply.FromString,
                )
        self.SpikeSorterGetState = channel.unary_unary(
                '/allego.Neurons1/SpikeSorterGetState',
                request_serializer=spikesorter__pb2.SpikeSorterStandardRequest.SerializeToString,
                response_deserializer=spikesorter__pb2.SpikeSorterState.FromString,
                )
        self.SpikeSorterGetDashboard = channel.unary_unary(
                '/allego.Neurons1/SpikeSorterGetDashboard',
                request_serializer=spikesorter__pb2.SpikeSorterGetDashboardRequest.SerializeToString,
                response_deserializer=spikesorter__pb2.SpikeSorterGetDashboardReply.FromString,
                )
        self.SpikeSorterGetRasterData = channel.unary_unary(
                '/allego.Neurons1/SpikeSorterGetRasterData',
                request_serializer=spikesorter__pb2.SpikeSorterGetRasterDataRequest.SerializeToString,
                response_deserializer=spikesorter__pb2.SpikeSorterRasterDataReply.FromString,
                )
        self.BiointerfaceGetSpikesDense = channel.unary_unary(
                '/allego.Neurons1/BiointerfaceGetSpikesDense',
                request_serializer=biointerface__pb2.BiointerfaceGetSpikesRequest.SerializeToString,
                response_deserializer=biointerface__pb2.BiointerfaceSpikeDataDenseReply.FromString,
                )
        self.BiointerfaceGetNeurons = channel.unary_unary(
                '/allego.Neurons1/BiointerfaceGetNeurons',
                request_serializer=biointerface__pb2.BiointerfaceGetNeuronsRequest.SerializeToString,
                response_deserializer=biointerface__pb2.BiointerfaceGetNeuronsReply.FromString,
                )
        self.BiointerfaceSeekEndSpikeTimestamps = channel.unary_unary(
                '/allego.Neurons1/BiointerfaceSeekEndSpikeTimestamps',
                request_serializer=biointerface__pb2.BiointerfaceSeekEndSpikeTimestampsRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                )
        self.SpikesGetSpec = channel.unary_unary(
                '/allego.Neurons1/SpikesGetSpec',
                request_serializer=datasource__pb2.DataSourceRequest.SerializeToString,
                response_deserializer=biointerface__pb2.SpikesSpecReply.FromString,
                )
        self.BiointerfaceViz = channel.unary_unary(
                '/allego.Neurons1/BiointerfaceViz',
                request_serializer=biointerface__pb2.BiointerfaceVizRequest.SerializeToString,
                response_deserializer=biointerface__pb2.BiointerfaceVizReply.FromString,
                )


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

    def Healthcheck(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 SpikeSorterCommand(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 SpikeSorterSetParam(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 SpikeSorterGetParam(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 SpikeSorterGetState(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 SpikeSorterGetDashboard(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 SpikeSorterGetRasterData(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 BiointerfaceGetSpikesDense(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 BiointerfaceGetNeurons(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 BiointerfaceSeekEndSpikeTimestamps(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 SpikesGetSpec(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 BiointerfaceViz(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_Neurons1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Healthcheck': grpc.unary_unary_rpc_method_handler(
                    servicer.Healthcheck,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SpikeSorterCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikeSorterCommand,
                    request_deserializer=spikesorter__pb2.SpikeSorterCommandRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SpikeSorterSetParam': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikeSorterSetParam,
                    request_deserializer=common__pb2.SpikeSorterSetParamRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SpikeSorterGetParam': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikeSorterGetParam,
                    request_deserializer=spikesorter__pb2.SpikeSorterStandardRequest.FromString,
                    response_serializer=spikesorter__pb2.GetSpikeSorterParamCommandReply.SerializeToString,
            ),
            'SpikeSorterGetState': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikeSorterGetState,
                    request_deserializer=spikesorter__pb2.SpikeSorterStandardRequest.FromString,
                    response_serializer=spikesorter__pb2.SpikeSorterState.SerializeToString,
            ),
            'SpikeSorterGetDashboard': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikeSorterGetDashboard,
                    request_deserializer=spikesorter__pb2.SpikeSorterGetDashboardRequest.FromString,
                    response_serializer=spikesorter__pb2.SpikeSorterGetDashboardReply.SerializeToString,
            ),
            'SpikeSorterGetRasterData': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikeSorterGetRasterData,
                    request_deserializer=spikesorter__pb2.SpikeSorterGetRasterDataRequest.FromString,
                    response_serializer=spikesorter__pb2.SpikeSorterRasterDataReply.SerializeToString,
            ),
            'BiointerfaceGetSpikesDense': grpc.unary_unary_rpc_method_handler(
                    servicer.BiointerfaceGetSpikesDense,
                    request_deserializer=biointerface__pb2.BiointerfaceGetSpikesRequest.FromString,
                    response_serializer=biointerface__pb2.BiointerfaceSpikeDataDenseReply.SerializeToString,
            ),
            'BiointerfaceGetNeurons': grpc.unary_unary_rpc_method_handler(
                    servicer.BiointerfaceGetNeurons,
                    request_deserializer=biointerface__pb2.BiointerfaceGetNeuronsRequest.FromString,
                    response_serializer=biointerface__pb2.BiointerfaceGetNeuronsReply.SerializeToString,
            ),
            'BiointerfaceSeekEndSpikeTimestamps': grpc.unary_unary_rpc_method_handler(
                    servicer.BiointerfaceSeekEndSpikeTimestamps,
                    request_deserializer=biointerface__pb2.BiointerfaceSeekEndSpikeTimestampsRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'SpikesGetSpec': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikesGetSpec,
                    request_deserializer=datasource__pb2.DataSourceRequest.FromString,
                    response_serializer=biointerface__pb2.SpikesSpecReply.SerializeToString,
            ),
            'BiointerfaceViz': grpc.unary_unary_rpc_method_handler(
                    servicer.BiointerfaceViz,
                    request_deserializer=biointerface__pb2.BiointerfaceVizRequest.FromString,
                    response_serializer=biointerface__pb2.BiointerfaceVizReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'allego.Neurons1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def Healthcheck(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, '/allego.Neurons1/Healthcheck',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikeSorterCommand(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, '/allego.Neurons1/SpikeSorterCommand',
            spikesorter__pb2.SpikeSorterCommandRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikeSorterSetParam(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, '/allego.Neurons1/SpikeSorterSetParam',
            common__pb2.SpikeSorterSetParamRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikeSorterGetParam(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, '/allego.Neurons1/SpikeSorterGetParam',
            spikesorter__pb2.SpikeSorterStandardRequest.SerializeToString,
            spikesorter__pb2.GetSpikeSorterParamCommandReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikeSorterGetState(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, '/allego.Neurons1/SpikeSorterGetState',
            spikesorter__pb2.SpikeSorterStandardRequest.SerializeToString,
            spikesorter__pb2.SpikeSorterState.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikeSorterGetDashboard(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, '/allego.Neurons1/SpikeSorterGetDashboard',
            spikesorter__pb2.SpikeSorterGetDashboardRequest.SerializeToString,
            spikesorter__pb2.SpikeSorterGetDashboardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikeSorterGetRasterData(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, '/allego.Neurons1/SpikeSorterGetRasterData',
            spikesorter__pb2.SpikeSorterGetRasterDataRequest.SerializeToString,
            spikesorter__pb2.SpikeSorterRasterDataReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def BiointerfaceGetSpikesDense(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, '/allego.Neurons1/BiointerfaceGetSpikesDense',
            biointerface__pb2.BiointerfaceGetSpikesRequest.SerializeToString,
            biointerface__pb2.BiointerfaceSpikeDataDenseReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def BiointerfaceGetNeurons(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, '/allego.Neurons1/BiointerfaceGetNeurons',
            biointerface__pb2.BiointerfaceGetNeuronsRequest.SerializeToString,
            biointerface__pb2.BiointerfaceGetNeuronsReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def BiointerfaceSeekEndSpikeTimestamps(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, '/allego.Neurons1/BiointerfaceSeekEndSpikeTimestamps',
            biointerface__pb2.BiointerfaceSeekEndSpikeTimestampsRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpikesGetSpec(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, '/allego.Neurons1/SpikesGetSpec',
            datasource__pb2.DataSourceRequest.SerializeToString,
            biointerface__pb2.SpikesSpecReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def BiointerfaceViz(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, '/allego.Neurons1/BiointerfaceViz',
            biointerface__pb2.BiointerfaceVizRequest.SerializeToString,
            biointerface__pb2.BiointerfaceVizReply.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
