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

from . import common_pb2 as common__pb2
from . import pybridge_pb2 as pybridge__pb2

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

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in pybridge_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Healthcheck = channel.unary_unary(
                '/allego.PyBridge/Healthcheck',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                _registered_method=True)
        self.Close = channel.unary_unary(
                '/allego.PyBridge/Close',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                _registered_method=True)
        self.IirFilterDesign = channel.unary_unary(
                '/allego.PyBridge/IirFilterDesign',
                request_serializer=pybridge__pb2.PyBridgeIirFilterDesignRequest.SerializeToString,
                response_deserializer=pybridge__pb2.PyBridgeIirFilterDesignReply.FromString,
                _registered_method=True)
        self.FileOpen = channel.unary_unary(
                '/allego.PyBridge/FileOpen',
                request_serializer=pybridge__pb2.PyBridgeFileOpenRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                _registered_method=True)
        self.FileGetStatus = channel.unary_unary(
                '/allego.PyBridge/FileGetStatus',
                request_serializer=pybridge__pb2.PyBridgeFileStandardRequest.SerializeToString,
                response_deserializer=pybridge__pb2.PyBridgeGetStatusReply.FromString,
                _registered_method=True)
        self.FileGetSpec = channel.unary_unary(
                '/allego.PyBridge/FileGetSpec',
                request_serializer=pybridge__pb2.PyBridgeFileStandardRequest.SerializeToString,
                response_deserializer=pybridge__pb2.PyBridgeGetSpecReply.FromString,
                _registered_method=True)
        self.FileGetSignals = channel.unary_unary(
                '/allego.PyBridge/FileGetSignals',
                request_serializer=pybridge__pb2.PyBridgeGetSignalsRequest.SerializeToString,
                response_deserializer=pybridge__pb2.PyBridgeGetSignalsReply.FromString,
                _registered_method=True)
        self.SpikesPushToExportFile = channel.unary_unary(
                '/allego.PyBridge/SpikesPushToExportFile',
                request_serializer=pybridge__pb2.SpikesPushToExportReq.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                _registered_method=True)
        self.LoadMearecOnPybridge = channel.unary_unary(
                '/allego.PyBridge/LoadMearecOnPybridge',
                request_serializer=pybridge__pb2.PyBridgeFileOpenRequest.SerializeToString,
                response_deserializer=pybridge__pb2.MearecFileMeta.FromString,
                _registered_method=True)
        self.SpikesSendMearecHDF5 = channel.unary_stream(
                '/allego.PyBridge/SpikesSendMearecHDF5',
                request_serializer=pybridge__pb2.MearecWaveformStreamRequest.SerializeToString,
                response_deserializer=pybridge__pb2.MearecWaveformChunk.FromString,
                _registered_method=True)
        self.SpikesCloseMearecHDF5 = channel.unary_unary(
                '/allego.PyBridge/SpikesCloseMearecHDF5',
                request_serializer=common__pb2.StandardRequest.SerializeToString,
                response_deserializer=common__pb2.StandardReply.FromString,
                _registered_method=True)
        self.GetMearecTemplate = channel.unary_unary(
                '/allego.PyBridge/GetMearecTemplate',
                request_serializer=pybridge__pb2.MearecTemplateRequest.SerializeToString,
                response_deserializer=pybridge__pb2.MearecTemplate.FromString,
                _registered_method=True)
        self.GetMearecWaveforms = channel.unary_unary(
                '/allego.PyBridge/GetMearecWaveforms',
                request_serializer=pybridge__pb2.MearecWaveformRequest.SerializeToString,
                response_deserializer=pybridge__pb2.MearecWaveformChunk.FromString,
                _registered_method=True)
        self.GetMearecSignals = channel.unary_unary(
                '/allego.PyBridge/GetMearecSignals',
                request_serializer=pybridge__pb2.MearecSignalRequest.SerializeToString,
                response_deserializer=pybridge__pb2.MearecSignalReply.FromString,
                _registered_method=True)
        self.StreamingRequest = channel.stream_unary(
                '/allego.PyBridge/StreamingRequest',
                request_serializer=pybridge__pb2.Request.SerializeToString,
                response_deserializer=pybridge__pb2.Reply.FromString,
                _registered_method=True)
        self.StreamingReply = channel.unary_stream(
                '/allego.PyBridge/StreamingReply',
                request_serializer=pybridge__pb2.Request.SerializeToString,
                response_deserializer=pybridge__pb2.Reply.FromString,
                _registered_method=True)
        self.StreamingBidirectional = channel.stream_stream(
                '/allego.PyBridge/StreamingBidirectional',
                request_serializer=pybridge__pb2.Request.SerializeToString,
                response_deserializer=pybridge__pb2.Reply.FromString,
                _registered_method=True)


class PyBridgeServicer(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 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 IirFilterDesign(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 FileOpen(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 FileGetStatus(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 FileGetSpec(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 FileGetSignals(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 SpikesPushToExportFile(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 LoadMearecOnPybridge(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 SpikesSendMearecHDF5(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 SpikesCloseMearecHDF5(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 GetMearecTemplate(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 GetMearecWaveforms(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 GetMearecSignals(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 StreamingRequest(self, request_iterator, context):
        """template functions
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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


def add_PyBridgeServicer_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,
            ),
            'Close': grpc.unary_unary_rpc_method_handler(
                    servicer.Close,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'IirFilterDesign': grpc.unary_unary_rpc_method_handler(
                    servicer.IirFilterDesign,
                    request_deserializer=pybridge__pb2.PyBridgeIirFilterDesignRequest.FromString,
                    response_serializer=pybridge__pb2.PyBridgeIirFilterDesignReply.SerializeToString,
            ),
            'FileOpen': grpc.unary_unary_rpc_method_handler(
                    servicer.FileOpen,
                    request_deserializer=pybridge__pb2.PyBridgeFileOpenRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'FileGetStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.FileGetStatus,
                    request_deserializer=pybridge__pb2.PyBridgeFileStandardRequest.FromString,
                    response_serializer=pybridge__pb2.PyBridgeGetStatusReply.SerializeToString,
            ),
            'FileGetSpec': grpc.unary_unary_rpc_method_handler(
                    servicer.FileGetSpec,
                    request_deserializer=pybridge__pb2.PyBridgeFileStandardRequest.FromString,
                    response_serializer=pybridge__pb2.PyBridgeGetSpecReply.SerializeToString,
            ),
            'FileGetSignals': grpc.unary_unary_rpc_method_handler(
                    servicer.FileGetSignals,
                    request_deserializer=pybridge__pb2.PyBridgeGetSignalsRequest.FromString,
                    response_serializer=pybridge__pb2.PyBridgeGetSignalsReply.SerializeToString,
            ),
            'SpikesPushToExportFile': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikesPushToExportFile,
                    request_deserializer=pybridge__pb2.SpikesPushToExportReq.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'LoadMearecOnPybridge': grpc.unary_unary_rpc_method_handler(
                    servicer.LoadMearecOnPybridge,
                    request_deserializer=pybridge__pb2.PyBridgeFileOpenRequest.FromString,
                    response_serializer=pybridge__pb2.MearecFileMeta.SerializeToString,
            ),
            'SpikesSendMearecHDF5': grpc.unary_stream_rpc_method_handler(
                    servicer.SpikesSendMearecHDF5,
                    request_deserializer=pybridge__pb2.MearecWaveformStreamRequest.FromString,
                    response_serializer=pybridge__pb2.MearecWaveformChunk.SerializeToString,
            ),
            'SpikesCloseMearecHDF5': grpc.unary_unary_rpc_method_handler(
                    servicer.SpikesCloseMearecHDF5,
                    request_deserializer=common__pb2.StandardRequest.FromString,
                    response_serializer=common__pb2.StandardReply.SerializeToString,
            ),
            'GetMearecTemplate': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMearecTemplate,
                    request_deserializer=pybridge__pb2.MearecTemplateRequest.FromString,
                    response_serializer=pybridge__pb2.MearecTemplate.SerializeToString,
            ),
            'GetMearecWaveforms': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMearecWaveforms,
                    request_deserializer=pybridge__pb2.MearecWaveformRequest.FromString,
                    response_serializer=pybridge__pb2.MearecWaveformChunk.SerializeToString,
            ),
            'GetMearecSignals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMearecSignals,
                    request_deserializer=pybridge__pb2.MearecSignalRequest.FromString,
                    response_serializer=pybridge__pb2.MearecSignalReply.SerializeToString,
            ),
            'StreamingRequest': grpc.stream_unary_rpc_method_handler(
                    servicer.StreamingRequest,
                    request_deserializer=pybridge__pb2.Request.FromString,
                    response_serializer=pybridge__pb2.Reply.SerializeToString,
            ),
            'StreamingReply': grpc.unary_stream_rpc_method_handler(
                    servicer.StreamingReply,
                    request_deserializer=pybridge__pb2.Request.FromString,
                    response_serializer=pybridge__pb2.Reply.SerializeToString,
            ),
            'StreamingBidirectional': grpc.stream_stream_rpc_method_handler(
                    servicer.StreamingBidirectional,
                    request_deserializer=pybridge__pb2.Request.FromString,
                    response_serializer=pybridge__pb2.Reply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'allego.PyBridge', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('allego.PyBridge', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class PyBridge(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.PyBridge/Healthcheck',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @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.PyBridge/Close',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IirFilterDesign(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.PyBridge/IirFilterDesign',
            pybridge__pb2.PyBridgeIirFilterDesignRequest.SerializeToString,
            pybridge__pb2.PyBridgeIirFilterDesignReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileOpen(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.PyBridge/FileOpen',
            pybridge__pb2.PyBridgeFileOpenRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileGetStatus(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.PyBridge/FileGetStatus',
            pybridge__pb2.PyBridgeFileStandardRequest.SerializeToString,
            pybridge__pb2.PyBridgeGetStatusReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileGetSpec(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.PyBridge/FileGetSpec',
            pybridge__pb2.PyBridgeFileStandardRequest.SerializeToString,
            pybridge__pb2.PyBridgeGetSpecReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileGetSignals(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.PyBridge/FileGetSignals',
            pybridge__pb2.PyBridgeGetSignalsRequest.SerializeToString,
            pybridge__pb2.PyBridgeGetSignalsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SpikesPushToExportFile(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.PyBridge/SpikesPushToExportFile',
            pybridge__pb2.SpikesPushToExportReq.SerializeToString,
            common__pb2.StandardReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LoadMearecOnPybridge(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.PyBridge/LoadMearecOnPybridge',
            pybridge__pb2.PyBridgeFileOpenRequest.SerializeToString,
            pybridge__pb2.MearecFileMeta.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SpikesSendMearecHDF5(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/allego.PyBridge/SpikesSendMearecHDF5',
            pybridge__pb2.MearecWaveformStreamRequest.SerializeToString,
            pybridge__pb2.MearecWaveformChunk.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SpikesCloseMearecHDF5(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.PyBridge/SpikesCloseMearecHDF5',
            common__pb2.StandardRequest.SerializeToString,
            common__pb2.StandardReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMearecTemplate(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.PyBridge/GetMearecTemplate',
            pybridge__pb2.MearecTemplateRequest.SerializeToString,
            pybridge__pb2.MearecTemplate.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMearecWaveforms(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.PyBridge/GetMearecWaveforms',
            pybridge__pb2.MearecWaveformRequest.SerializeToString,
            pybridge__pb2.MearecWaveformChunk.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMearecSignals(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.PyBridge/GetMearecSignals',
            pybridge__pb2.MearecSignalRequest.SerializeToString,
            pybridge__pb2.MearecSignalReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamingRequest(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            '/allego.PyBridge/StreamingRequest',
            pybridge__pb2.Request.SerializeToString,
            pybridge__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamingReply(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/allego.PyBridge/StreamingReply',
            pybridge__pb2.Request.SerializeToString,
            pybridge__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamingBidirectional(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/allego.PyBridge/StreamingBidirectional',
            pybridge__pb2.Request.SerializeToString,
            pybridge__pb2.Reply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
