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

import coinlib.dataWorker_pb2 as dataWorker__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.ChartsWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.ChartsWorkerConfig.FromString,
                )
        self.OnIndicatorErrorOccured = channel.unary_unary(
                '/coinlib.ChartsWorker/OnIndicatorErrorOccured',
                request_serializer=dataWorker__pb2.IndicatorError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnPartialChartLayout = channel.unary_unary(
                '/coinlib.ChartsWorker/OnPartialChartLayout',
                request_serializer=dataWorker__pb2.ChartsWorkerPartialDataLayout.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnIndicatorErrorOccured(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 OnPartialChartLayout(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_ChartsWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.ChartsWorkerConfig.SerializeToString,
            ),
            'OnIndicatorErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnIndicatorErrorOccured,
                    request_deserializer=dataWorker__pb2.IndicatorError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnPartialChartLayout': grpc.unary_unary_rpc_method_handler(
                    servicer.OnPartialChartLayout,
                    request_deserializer=dataWorker__pb2.ChartsWorkerPartialDataLayout.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.ChartsWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.ChartsWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.ChartsWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnIndicatorErrorOccured(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, '/coinlib.ChartsWorker/OnIndicatorErrorOccured',
            dataWorker__pb2.IndicatorError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnPartialChartLayout(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, '/coinlib.ChartsWorker/OnPartialChartLayout',
            dataWorker__pb2.ChartsWorkerPartialDataLayout.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.StatisticsMethodWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.StatisticsBulkedWorkerConfig.FromString,
                )
        self.OnStatisticPartiallyData = channel.unary_unary(
                '/coinlib.StatisticsMethodWorker/OnStatisticPartiallyData',
                request_serializer=dataWorker__pb2.StatisticBulkedPartiallyData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnStatisticFunctionErrorOccured = channel.unary_unary(
                '/coinlib.StatisticsMethodWorker/OnStatisticFunctionErrorOccured',
                request_serializer=dataWorker__pb2.StatisticFunctionError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnStatisticPartiallyData(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 OnStatisticFunctionErrorOccured(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_StatisticsMethodWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.StatisticsBulkedWorkerConfig.SerializeToString,
            ),
            'OnStatisticPartiallyData': grpc.unary_unary_rpc_method_handler(
                    servicer.OnStatisticPartiallyData,
                    request_deserializer=dataWorker__pb2.StatisticBulkedPartiallyData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnStatisticFunctionErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnStatisticFunctionErrorOccured,
                    request_deserializer=dataWorker__pb2.StatisticFunctionError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.StatisticsMethodWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.StatisticsMethodWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.StatisticsBulkedWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnStatisticPartiallyData(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, '/coinlib.StatisticsMethodWorker/OnStatisticPartiallyData',
            dataWorker__pb2.StatisticBulkedPartiallyData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnStatisticFunctionErrorOccured(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, '/coinlib.StatisticsMethodWorker/OnStatisticFunctionErrorOccured',
            dataWorker__pb2.StatisticFunctionError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.SymbolBrokerWorkerConfig.FromString,
                )
        self.waitForConsumerStopped = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/waitForConsumerStopped',
                request_serializer=dataWorker__pb2.SymbolBrokerStopConsumerListener.SerializeToString,
                response_deserializer=dataWorker__pb2.SymbolBrokerStopConsumerCommand.FromString,
                )
        self.onHistoricalDataReceived = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/onHistoricalDataReceived',
                request_serializer=dataWorker__pb2.SymbolBrokerHistoricalMarketData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.onBrokerSymbolInfoReceived = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/onBrokerSymbolInfoReceived',
                request_serializer=dataWorker__pb2.SymbolBrokerInfo.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.onMarketDataReceived = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/onMarketDataReceived',
                request_serializer=dataWorker__pb2.SymbolBrokerMarketData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.onOrderbookReceived = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/onOrderbookReceived',
                request_serializer=dataWorker__pb2.SymbolBrokerOrderbook.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnSymbolBrokerErrorOccured = channel.unary_unary(
                '/coinlib.SymbolBrokerWorker/OnSymbolBrokerErrorOccured',
                request_serializer=dataWorker__pb2.SymbolBrokerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 waitForConsumerStopped(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 onHistoricalDataReceived(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 onBrokerSymbolInfoReceived(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 onMarketDataReceived(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 onOrderbookReceived(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 OnSymbolBrokerErrorOccured(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_SymbolBrokerWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.SymbolBrokerWorkerConfig.SerializeToString,
            ),
            'waitForConsumerStopped': grpc.unary_unary_rpc_method_handler(
                    servicer.waitForConsumerStopped,
                    request_deserializer=dataWorker__pb2.SymbolBrokerStopConsumerListener.FromString,
                    response_serializer=dataWorker__pb2.SymbolBrokerStopConsumerCommand.SerializeToString,
            ),
            'onHistoricalDataReceived': grpc.unary_unary_rpc_method_handler(
                    servicer.onHistoricalDataReceived,
                    request_deserializer=dataWorker__pb2.SymbolBrokerHistoricalMarketData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'onBrokerSymbolInfoReceived': grpc.unary_unary_rpc_method_handler(
                    servicer.onBrokerSymbolInfoReceived,
                    request_deserializer=dataWorker__pb2.SymbolBrokerInfo.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'onMarketDataReceived': grpc.unary_unary_rpc_method_handler(
                    servicer.onMarketDataReceived,
                    request_deserializer=dataWorker__pb2.SymbolBrokerMarketData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'onOrderbookReceived': grpc.unary_unary_rpc_method_handler(
                    servicer.onOrderbookReceived,
                    request_deserializer=dataWorker__pb2.SymbolBrokerOrderbook.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnSymbolBrokerErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnSymbolBrokerErrorOccured,
                    request_deserializer=dataWorker__pb2.SymbolBrokerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.SymbolBrokerWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.SymbolBrokerWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.SymbolBrokerWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def waitForConsumerStopped(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, '/coinlib.SymbolBrokerWorker/waitForConsumerStopped',
            dataWorker__pb2.SymbolBrokerStopConsumerListener.SerializeToString,
            dataWorker__pb2.SymbolBrokerStopConsumerCommand.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def onHistoricalDataReceived(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, '/coinlib.SymbolBrokerWorker/onHistoricalDataReceived',
            dataWorker__pb2.SymbolBrokerHistoricalMarketData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def onBrokerSymbolInfoReceived(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, '/coinlib.SymbolBrokerWorker/onBrokerSymbolInfoReceived',
            dataWorker__pb2.SymbolBrokerInfo.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def onMarketDataReceived(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, '/coinlib.SymbolBrokerWorker/onMarketDataReceived',
            dataWorker__pb2.SymbolBrokerMarketData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def onOrderbookReceived(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, '/coinlib.SymbolBrokerWorker/onOrderbookReceived',
            dataWorker__pb2.SymbolBrokerOrderbook.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnSymbolBrokerErrorOccured(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, '/coinlib.SymbolBrokerWorker/OnSymbolBrokerErrorOccured',
            dataWorker__pb2.SymbolBrokerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.NotificationWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.NotificationWorkerConfig.FromString,
                )
        self.OnCallbackDataExtracted = channel.unary_unary(
                '/coinlib.NotificationWorker/OnCallbackDataExtracted',
                request_serializer=dataWorker__pb2.NotificationCallbackExtract.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnNotificationErrorOccured = channel.unary_unary(
                '/coinlib.NotificationWorker/OnNotificationErrorOccured',
                request_serializer=dataWorker__pb2.NotificationError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnCallbackDataExtracted(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 OnNotificationErrorOccured(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_NotificationWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.NotificationWorkerConfig.SerializeToString,
            ),
            'OnCallbackDataExtracted': grpc.unary_unary_rpc_method_handler(
                    servicer.OnCallbackDataExtracted,
                    request_deserializer=dataWorker__pb2.NotificationCallbackExtract.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnNotificationErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnNotificationErrorOccured,
                    request_deserializer=dataWorker__pb2.NotificationError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.NotificationWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.NotificationWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.NotificationWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnCallbackDataExtracted(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, '/coinlib.NotificationWorker/OnCallbackDataExtracted',
            dataWorker__pb2.NotificationCallbackExtract.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnNotificationErrorOccured(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, '/coinlib.NotificationWorker/OnNotificationErrorOccured',
            dataWorker__pb2.NotificationError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.LogicRunnerOfflineService/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.LogicRunnerOfflineWorkerConfig.FromString,
                )
        self.OnRunnerPartiallyData = channel.unary_unary(
                '/coinlib.LogicRunnerOfflineService/OnRunnerPartiallyData',
                request_serializer=dataWorker__pb2.LogicRunnerOfflineWorkerPartiallyData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnRunnerErrorOccured = channel.unary_unary(
                '/coinlib.LogicRunnerOfflineService/OnRunnerErrorOccured',
                request_serializer=dataWorker__pb2.LogicRunnerOfflineWorkerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnRunnerFinishedComplete = channel.unary_unary(
                '/coinlib.LogicRunnerOfflineService/OnRunnerFinishedComplete',
                request_serializer=dataWorker__pb2.LogicRunnerOfflineWorkerFinishedData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnRunnerPartiallyData(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 OnRunnerErrorOccured(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 OnRunnerFinishedComplete(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_LogicRunnerOfflineServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.LogicRunnerOfflineWorkerConfig.SerializeToString,
            ),
            'OnRunnerPartiallyData': grpc.unary_unary_rpc_method_handler(
                    servicer.OnRunnerPartiallyData,
                    request_deserializer=dataWorker__pb2.LogicRunnerOfflineWorkerPartiallyData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnRunnerErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnRunnerErrorOccured,
                    request_deserializer=dataWorker__pb2.LogicRunnerOfflineWorkerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnRunnerFinishedComplete': grpc.unary_unary_rpc_method_handler(
                    servicer.OnRunnerFinishedComplete,
                    request_deserializer=dataWorker__pb2.LogicRunnerOfflineWorkerFinishedData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.LogicRunnerOfflineService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.LogicRunnerOfflineService/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.LogicRunnerOfflineWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnRunnerPartiallyData(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, '/coinlib.LogicRunnerOfflineService/OnRunnerPartiallyData',
            dataWorker__pb2.LogicRunnerOfflineWorkerPartiallyData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnRunnerErrorOccured(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, '/coinlib.LogicRunnerOfflineService/OnRunnerErrorOccured',
            dataWorker__pb2.LogicRunnerOfflineWorkerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnRunnerFinishedComplete(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, '/coinlib.LogicRunnerOfflineService/OnRunnerFinishedComplete',
            dataWorker__pb2.LogicRunnerOfflineWorkerFinishedData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.AcceptWorkerJob = channel.unary_unary(
                '/coinlib.DataWorker/AcceptWorkerJob',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.DeclineWorkerJob = channel.unary_unary(
                '/coinlib.DataWorker/DeclineWorkerJob',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.RegisterWorker = channel.unary_unary(
                '/coinlib.DataWorker/RegisterWorker',
                request_serializer=dataWorker__pb2.Worker.SerializeToString,
                response_deserializer=dataWorker__pb2.WorkerSettings.FromString,
                )
        self.GetAllPlugins = channel.unary_unary(
                '/coinlib.DataWorker/GetAllPlugins',
                request_serializer=dataWorker__pb2.Worker.SerializeToString,
                response_deserializer=dataWorker__pb2.WorkerPluginInformation.FromString,
                )
        self.UpdateWorkerJob = channel.unary_unary(
                '/coinlib.DataWorker/UpdateWorkerJob',
                request_serializer=dataWorker__pb2.WorkerJobDataResponse.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.WatchWorkerJobs = channel.stream_stream(
                '/coinlib.DataWorker/WatchWorkerJobs',
                request_serializer=dataWorker__pb2.WorkerRegistration.SerializeToString,
                response_deserializer=dataWorker__pb2.WorkerJob.FromString,
                )
        self.FinishedWorkerJob = channel.unary_unary(
                '/coinlib.DataWorker/FinishedWorkerJob',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.ErroredWorkerJob = channel.unary_unary(
                '/coinlib.DataWorker/ErroredWorkerJob',
                request_serializer=dataWorker__pb2.WorkerJobError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def AcceptWorkerJob(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 DeclineWorkerJob(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 RegisterWorker(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 GetAllPlugins(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 UpdateWorkerJob(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 WatchWorkerJobs(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 FinishedWorkerJob(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 ErroredWorkerJob(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_DataWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AcceptWorkerJob': grpc.unary_unary_rpc_method_handler(
                    servicer.AcceptWorkerJob,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'DeclineWorkerJob': grpc.unary_unary_rpc_method_handler(
                    servicer.DeclineWorkerJob,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'RegisterWorker': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterWorker,
                    request_deserializer=dataWorker__pb2.Worker.FromString,
                    response_serializer=dataWorker__pb2.WorkerSettings.SerializeToString,
            ),
            'GetAllPlugins': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAllPlugins,
                    request_deserializer=dataWorker__pb2.Worker.FromString,
                    response_serializer=dataWorker__pb2.WorkerPluginInformation.SerializeToString,
            ),
            'UpdateWorkerJob': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateWorkerJob,
                    request_deserializer=dataWorker__pb2.WorkerJobDataResponse.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'WatchWorkerJobs': grpc.stream_stream_rpc_method_handler(
                    servicer.WatchWorkerJobs,
                    request_deserializer=dataWorker__pb2.WorkerRegistration.FromString,
                    response_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
            ),
            'FinishedWorkerJob': grpc.unary_unary_rpc_method_handler(
                    servicer.FinishedWorkerJob,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'ErroredWorkerJob': grpc.unary_unary_rpc_method_handler(
                    servicer.ErroredWorkerJob,
                    request_deserializer=dataWorker__pb2.WorkerJobError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.DataWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def AcceptWorkerJob(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, '/coinlib.DataWorker/AcceptWorkerJob',
            dataWorker__pb2.WorkerJob.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeclineWorkerJob(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, '/coinlib.DataWorker/DeclineWorkerJob',
            dataWorker__pb2.WorkerJob.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterWorker(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, '/coinlib.DataWorker/RegisterWorker',
            dataWorker__pb2.Worker.SerializeToString,
            dataWorker__pb2.WorkerSettings.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetAllPlugins(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, '/coinlib.DataWorker/GetAllPlugins',
            dataWorker__pb2.Worker.SerializeToString,
            dataWorker__pb2.WorkerPluginInformation.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateWorkerJob(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, '/coinlib.DataWorker/UpdateWorkerJob',
            dataWorker__pb2.WorkerJobDataResponse.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WatchWorkerJobs(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, '/coinlib.DataWorker/WatchWorkerJobs',
            dataWorker__pb2.WorkerRegistration.SerializeToString,
            dataWorker__pb2.WorkerJob.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def FinishedWorkerJob(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, '/coinlib.DataWorker/FinishedWorkerJob',
            dataWorker__pb2.WorkerJob.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ErroredWorkerJob(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, '/coinlib.DataWorker/ErroredWorkerJob',
            dataWorker__pb2.WorkerJobError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.PluginWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.PluginConfig.FromString,
                )
        self.OnInstallationOutput = channel.stream_unary(
                '/coinlib.PluginWorker/OnInstallationOutput',
                request_serializer=dataWorker__pb2.PluginInstallationOutput.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnInstallationOutput(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_PluginWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.PluginConfig.SerializeToString,
            ),
            'OnInstallationOutput': grpc.stream_unary_rpc_method_handler(
                    servicer.OnInstallationOutput,
                    request_deserializer=dataWorker__pb2.PluginInstallationOutput.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.PluginWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.PluginWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.PluginConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnInstallationOutput(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, '/coinlib.PluginWorker/OnInstallationOutput',
            dataWorker__pb2.PluginInstallationOutput.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.simulateFeature = channel.unary_unary(
                '/coinlib.Simulator/simulateFeature',
                request_serializer=dataWorker__pb2.FeatureSimulatorRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.FeatureSimulatorResponse.FromString,
                )
        self.simulateChart = channel.unary_unary(
                '/coinlib.Simulator/simulateChart',
                request_serializer=dataWorker__pb2.SimulatorChartConfig.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.simulateStatisticsRule = channel.unary_unary(
                '/coinlib.Simulator/simulateStatisticsRule',
                request_serializer=dataWorker__pb2.SimulatorStatisticChartConfig.SerializeToString,
                response_deserializer=dataWorker__pb2.SimulatorResponse.FromString,
                )
        self.simulateStatisticsMethod = channel.unary_unary(
                '/coinlib.Simulator/simulateStatisticsMethod',
                request_serializer=dataWorker__pb2.SimulatorMethodCallChartConfig.SerializeToString,
                response_deserializer=dataWorker__pb2.SimulatorResponse.FromString,
                )
        self.simulateSymbolBroker = channel.unary_unary(
                '/coinlib.Simulator/simulateSymbolBroker',
                request_serializer=dataWorker__pb2.SymbolBrokerSimulatorRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.SymbolBrokerSimulatorResponse.FromString,
                )
        self.simulateBroker = channel.unary_unary(
                '/coinlib.Simulator/simulateBroker',
                request_serializer=dataWorker__pb2.BrokerSimulatorRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.BrokerSimulatorResponse.FromString,
                )
        self.simulateNotification = channel.unary_unary(
                '/coinlib.Simulator/simulateNotification',
                request_serializer=dataWorker__pb2.NotificationSimulatorRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.NotificationSimulatorResponse.FromString,
                )


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

    def simulateFeature(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 simulateChart(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 simulateStatisticsRule(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 simulateStatisticsMethod(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 simulateSymbolBroker(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 simulateBroker(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 simulateNotification(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_SimulatorServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'simulateFeature': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateFeature,
                    request_deserializer=dataWorker__pb2.FeatureSimulatorRequest.FromString,
                    response_serializer=dataWorker__pb2.FeatureSimulatorResponse.SerializeToString,
            ),
            'simulateChart': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateChart,
                    request_deserializer=dataWorker__pb2.SimulatorChartConfig.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'simulateStatisticsRule': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateStatisticsRule,
                    request_deserializer=dataWorker__pb2.SimulatorStatisticChartConfig.FromString,
                    response_serializer=dataWorker__pb2.SimulatorResponse.SerializeToString,
            ),
            'simulateStatisticsMethod': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateStatisticsMethod,
                    request_deserializer=dataWorker__pb2.SimulatorMethodCallChartConfig.FromString,
                    response_serializer=dataWorker__pb2.SimulatorResponse.SerializeToString,
            ),
            'simulateSymbolBroker': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateSymbolBroker,
                    request_deserializer=dataWorker__pb2.SymbolBrokerSimulatorRequest.FromString,
                    response_serializer=dataWorker__pb2.SymbolBrokerSimulatorResponse.SerializeToString,
            ),
            'simulateBroker': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateBroker,
                    request_deserializer=dataWorker__pb2.BrokerSimulatorRequest.FromString,
                    response_serializer=dataWorker__pb2.BrokerSimulatorResponse.SerializeToString,
            ),
            'simulateNotification': grpc.unary_unary_rpc_method_handler(
                    servicer.simulateNotification,
                    request_deserializer=dataWorker__pb2.NotificationSimulatorRequest.FromString,
                    response_serializer=dataWorker__pb2.NotificationSimulatorResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Simulator', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def simulateFeature(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, '/coinlib.Simulator/simulateFeature',
            dataWorker__pb2.FeatureSimulatorRequest.SerializeToString,
            dataWorker__pb2.FeatureSimulatorResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def simulateChart(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, '/coinlib.Simulator/simulateChart',
            dataWorker__pb2.SimulatorChartConfig.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def simulateStatisticsRule(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, '/coinlib.Simulator/simulateStatisticsRule',
            dataWorker__pb2.SimulatorStatisticChartConfig.SerializeToString,
            dataWorker__pb2.SimulatorResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def simulateStatisticsMethod(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, '/coinlib.Simulator/simulateStatisticsMethod',
            dataWorker__pb2.SimulatorMethodCallChartConfig.SerializeToString,
            dataWorker__pb2.SimulatorResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def simulateSymbolBroker(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, '/coinlib.Simulator/simulateSymbolBroker',
            dataWorker__pb2.SymbolBrokerSimulatorRequest.SerializeToString,
            dataWorker__pb2.SymbolBrokerSimulatorResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def simulateBroker(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, '/coinlib.Simulator/simulateBroker',
            dataWorker__pb2.BrokerSimulatorRequest.SerializeToString,
            dataWorker__pb2.BrokerSimulatorResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def simulateNotification(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, '/coinlib.Simulator/simulateNotification',
            dataWorker__pb2.NotificationSimulatorRequest.SerializeToString,
            dataWorker__pb2.NotificationSimulatorResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerIndicatorFunction = channel.unary_unary(
                '/coinlib.Functions/registerIndicatorFunction',
                request_serializer=dataWorker__pb2.ChartWorkerIndicatorRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerIndicatorFunction(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_FunctionsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerIndicatorFunction': grpc.unary_unary_rpc_method_handler(
                    servicer.registerIndicatorFunction,
                    request_deserializer=dataWorker__pb2.ChartWorkerIndicatorRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Functions', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerIndicatorFunction(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, '/coinlib.Functions/registerIndicatorFunction',
            dataWorker__pb2.ChartWorkerIndicatorRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerTrader = channel.unary_unary(
                '/coinlib.Logic/registerTrader',
                request_serializer=dataWorker__pb2.LogicTraderRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.registerScreener = channel.unary_unary(
                '/coinlib.Logic/registerScreener',
                request_serializer=dataWorker__pb2.LogicScreenerRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.registerAdvisor = channel.unary_unary(
                '/coinlib.Logic/registerAdvisor',
                request_serializer=dataWorker__pb2.LogicAdvisorRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.addLogicToWorkspace = channel.unary_unary(
                '/coinlib.Logic/addLogicToWorkspace',
                request_serializer=dataWorker__pb2.WorkspaceLogicRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerTrader(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 registerScreener(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 registerAdvisor(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 addLogicToWorkspace(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_LogicServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerTrader': grpc.unary_unary_rpc_method_handler(
                    servicer.registerTrader,
                    request_deserializer=dataWorker__pb2.LogicTraderRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'registerScreener': grpc.unary_unary_rpc_method_handler(
                    servicer.registerScreener,
                    request_deserializer=dataWorker__pb2.LogicScreenerRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'registerAdvisor': grpc.unary_unary_rpc_method_handler(
                    servicer.registerAdvisor,
                    request_deserializer=dataWorker__pb2.LogicAdvisorRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'addLogicToWorkspace': grpc.unary_unary_rpc_method_handler(
                    servicer.addLogicToWorkspace,
                    request_deserializer=dataWorker__pb2.WorkspaceLogicRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Logic', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerTrader(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, '/coinlib.Logic/registerTrader',
            dataWorker__pb2.LogicTraderRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def registerScreener(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, '/coinlib.Logic/registerScreener',
            dataWorker__pb2.LogicScreenerRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def registerAdvisor(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, '/coinlib.Logic/registerAdvisor',
            dataWorker__pb2.LogicAdvisorRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def addLogicToWorkspace(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, '/coinlib.Logic/addLogicToWorkspace',
            dataWorker__pb2.WorkspaceLogicRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerBroker = channel.unary_unary(
                '/coinlib.Broker/registerBroker',
                request_serializer=dataWorker__pb2.BrokerRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerBroker(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_BrokerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerBroker': grpc.unary_unary_rpc_method_handler(
                    servicer.registerBroker,
                    request_deserializer=dataWorker__pb2.BrokerRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Broker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerBroker(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, '/coinlib.Broker/registerBroker',
            dataWorker__pb2.BrokerRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.BrokerWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.BrokerWorkerConfig.FromString,
                )
        self.OnBrokerErrorOccured = channel.unary_unary(
                '/coinlib.BrokerWorker/OnBrokerErrorOccured',
                request_serializer=dataWorker__pb2.BrokerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.WatchBrokerCommands = channel.stream_stream(
                '/coinlib.BrokerWorker/WatchBrokerCommands',
                request_serializer=dataWorker__pb2.BrokerCommandRegistration.SerializeToString,
                response_deserializer=dataWorker__pb2.BrokerCommands.FromString,
                )
        self.SendCommandAnswer = channel.unary_unary(
                '/coinlib.BrokerWorker/SendCommandAnswer',
                request_serializer=dataWorker__pb2.BrokerCommandsAnswer.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.SendCommandAnswerError = channel.unary_unary(
                '/coinlib.BrokerWorker/SendCommandAnswerError',
                request_serializer=dataWorker__pb2.BrokerCommandsAnswerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.RegisterBrokerSession = channel.unary_unary(
                '/coinlib.BrokerWorker/RegisterBrokerSession',
                request_serializer=dataWorker__pb2.BrokerSessionRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnBrokerEvent = channel.unary_unary(
                '/coinlib.BrokerWorker/OnBrokerEvent',
                request_serializer=dataWorker__pb2.BrokerEventData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnBrokerErrorOccured(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 WatchBrokerCommands(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 SendCommandAnswer(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 SendCommandAnswerError(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 RegisterBrokerSession(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 OnBrokerEvent(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_BrokerWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.BrokerWorkerConfig.SerializeToString,
            ),
            'OnBrokerErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnBrokerErrorOccured,
                    request_deserializer=dataWorker__pb2.BrokerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'WatchBrokerCommands': grpc.stream_stream_rpc_method_handler(
                    servicer.WatchBrokerCommands,
                    request_deserializer=dataWorker__pb2.BrokerCommandRegistration.FromString,
                    response_serializer=dataWorker__pb2.BrokerCommands.SerializeToString,
            ),
            'SendCommandAnswer': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommandAnswer,
                    request_deserializer=dataWorker__pb2.BrokerCommandsAnswer.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'SendCommandAnswerError': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommandAnswerError,
                    request_deserializer=dataWorker__pb2.BrokerCommandsAnswerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'RegisterBrokerSession': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterBrokerSession,
                    request_deserializer=dataWorker__pb2.BrokerSessionRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnBrokerEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.OnBrokerEvent,
                    request_deserializer=dataWorker__pb2.BrokerEventData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.BrokerWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.BrokerWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.BrokerWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnBrokerErrorOccured(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, '/coinlib.BrokerWorker/OnBrokerErrorOccured',
            dataWorker__pb2.BrokerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WatchBrokerCommands(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, '/coinlib.BrokerWorker/WatchBrokerCommands',
            dataWorker__pb2.BrokerCommandRegistration.SerializeToString,
            dataWorker__pb2.BrokerCommands.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendCommandAnswer(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, '/coinlib.BrokerWorker/SendCommandAnswer',
            dataWorker__pb2.BrokerCommandsAnswer.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendCommandAnswerError(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, '/coinlib.BrokerWorker/SendCommandAnswerError',
            dataWorker__pb2.BrokerCommandsAnswerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterBrokerSession(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, '/coinlib.BrokerWorker/RegisterBrokerSession',
            dataWorker__pb2.BrokerSessionRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnBrokerEvent(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, '/coinlib.BrokerWorker/OnBrokerEvent',
            dataWorker__pb2.BrokerEventData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.AppWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.AppWorkerConfig.FromString,
                )
        self.OnAppWorkerErrorOccured = channel.unary_unary(
                '/coinlib.AppWorker/OnAppWorkerErrorOccured',
                request_serializer=dataWorker__pb2.AppWorkerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.WatchBrokerCommands = channel.stream_stream(
                '/coinlib.AppWorker/WatchBrokerCommands',
                request_serializer=dataWorker__pb2.AppWorkerCommandRegistration.SerializeToString,
                response_deserializer=dataWorker__pb2.AppWorkerCommands.FromString,
                )
        self.RunModuleCommand = channel.unary_unary(
                '/coinlib.AppWorker/RunModuleCommand',
                request_serializer=dataWorker__pb2.AppWorkerModuleCommand.SerializeToString,
                response_deserializer=dataWorker__pb2.AppWorkerModuleCommandAnswer.FromString,
                )
        self.RunBrokerCommand = channel.unary_unary(
                '/coinlib.AppWorker/RunBrokerCommand',
                request_serializer=dataWorker__pb2.AppWorkerBrokerCommand.SerializeToString,
                response_deserializer=dataWorker__pb2.AppWorkerBrokerCommandAnswer.FromString,
                )
        self.WatchAppWorkerCommands = channel.stream_stream(
                '/coinlib.AppWorker/WatchAppWorkerCommands',
                request_serializer=dataWorker__pb2.AppWorkerCommandRegistration.SerializeToString,
                response_deserializer=dataWorker__pb2.AppWorkerCommands.FromString,
                )
        self.SendCommandAnswer = channel.unary_unary(
                '/coinlib.AppWorker/SendCommandAnswer',
                request_serializer=dataWorker__pb2.AppWorkerCommandsAnswer.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.SendCommandAnswerError = channel.unary_unary(
                '/coinlib.AppWorker/SendCommandAnswerError',
                request_serializer=dataWorker__pb2.AppWorkerCommandsAnswerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnAppWorkerLogicFinished = channel.unary_unary(
                '/coinlib.AppWorker/OnAppWorkerLogicFinished',
                request_serializer=dataWorker__pb2.AppWorkerFinishedStepInfos.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.RegisterAppWorkerSession = channel.unary_unary(
                '/coinlib.AppWorker/RegisterAppWorkerSession',
                request_serializer=dataWorker__pb2.AppWorkerSessionRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnAppWorkerEvent = channel.unary_unary(
                '/coinlib.AppWorker/OnAppWorkerEvent',
                request_serializer=dataWorker__pb2.AppWorkerEventData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.OnBrokerTestResult = channel.unary_unary(
                '/coinlib.AppWorker/OnBrokerTestResult',
                request_serializer=dataWorker__pb2.BrokerTestProtocolData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnAppWorkerErrorOccured(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 WatchBrokerCommands(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 RunModuleCommand(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 RunBrokerCommand(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 WatchAppWorkerCommands(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 SendCommandAnswer(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 SendCommandAnswerError(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 OnAppWorkerLogicFinished(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 RegisterAppWorkerSession(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 OnAppWorkerEvent(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 OnBrokerTestResult(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_AppWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.AppWorkerConfig.SerializeToString,
            ),
            'OnAppWorkerErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnAppWorkerErrorOccured,
                    request_deserializer=dataWorker__pb2.AppWorkerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'WatchBrokerCommands': grpc.stream_stream_rpc_method_handler(
                    servicer.WatchBrokerCommands,
                    request_deserializer=dataWorker__pb2.AppWorkerCommandRegistration.FromString,
                    response_serializer=dataWorker__pb2.AppWorkerCommands.SerializeToString,
            ),
            'RunModuleCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.RunModuleCommand,
                    request_deserializer=dataWorker__pb2.AppWorkerModuleCommand.FromString,
                    response_serializer=dataWorker__pb2.AppWorkerModuleCommandAnswer.SerializeToString,
            ),
            'RunBrokerCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.RunBrokerCommand,
                    request_deserializer=dataWorker__pb2.AppWorkerBrokerCommand.FromString,
                    response_serializer=dataWorker__pb2.AppWorkerBrokerCommandAnswer.SerializeToString,
            ),
            'WatchAppWorkerCommands': grpc.stream_stream_rpc_method_handler(
                    servicer.WatchAppWorkerCommands,
                    request_deserializer=dataWorker__pb2.AppWorkerCommandRegistration.FromString,
                    response_serializer=dataWorker__pb2.AppWorkerCommands.SerializeToString,
            ),
            'SendCommandAnswer': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommandAnswer,
                    request_deserializer=dataWorker__pb2.AppWorkerCommandsAnswer.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'SendCommandAnswerError': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommandAnswerError,
                    request_deserializer=dataWorker__pb2.AppWorkerCommandsAnswerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnAppWorkerLogicFinished': grpc.unary_unary_rpc_method_handler(
                    servicer.OnAppWorkerLogicFinished,
                    request_deserializer=dataWorker__pb2.AppWorkerFinishedStepInfos.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'RegisterAppWorkerSession': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterAppWorkerSession,
                    request_deserializer=dataWorker__pb2.AppWorkerSessionRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnAppWorkerEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.OnAppWorkerEvent,
                    request_deserializer=dataWorker__pb2.AppWorkerEventData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'OnBrokerTestResult': grpc.unary_unary_rpc_method_handler(
                    servicer.OnBrokerTestResult,
                    request_deserializer=dataWorker__pb2.BrokerTestProtocolData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.AppWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.AppWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.AppWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnAppWorkerErrorOccured(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, '/coinlib.AppWorker/OnAppWorkerErrorOccured',
            dataWorker__pb2.AppWorkerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WatchBrokerCommands(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, '/coinlib.AppWorker/WatchBrokerCommands',
            dataWorker__pb2.AppWorkerCommandRegistration.SerializeToString,
            dataWorker__pb2.AppWorkerCommands.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RunModuleCommand(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, '/coinlib.AppWorker/RunModuleCommand',
            dataWorker__pb2.AppWorkerModuleCommand.SerializeToString,
            dataWorker__pb2.AppWorkerModuleCommandAnswer.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RunBrokerCommand(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, '/coinlib.AppWorker/RunBrokerCommand',
            dataWorker__pb2.AppWorkerBrokerCommand.SerializeToString,
            dataWorker__pb2.AppWorkerBrokerCommandAnswer.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WatchAppWorkerCommands(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, '/coinlib.AppWorker/WatchAppWorkerCommands',
            dataWorker__pb2.AppWorkerCommandRegistration.SerializeToString,
            dataWorker__pb2.AppWorkerCommands.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendCommandAnswer(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, '/coinlib.AppWorker/SendCommandAnswer',
            dataWorker__pb2.AppWorkerCommandsAnswer.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendCommandAnswerError(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, '/coinlib.AppWorker/SendCommandAnswerError',
            dataWorker__pb2.AppWorkerCommandsAnswerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnAppWorkerLogicFinished(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, '/coinlib.AppWorker/OnAppWorkerLogicFinished',
            dataWorker__pb2.AppWorkerFinishedStepInfos.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterAppWorkerSession(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, '/coinlib.AppWorker/RegisterAppWorkerSession',
            dataWorker__pb2.AppWorkerSessionRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnAppWorkerEvent(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, '/coinlib.AppWorker/OnAppWorkerEvent',
            dataWorker__pb2.AppWorkerEventData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnBrokerTestResult(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, '/coinlib.AppWorker/OnBrokerTestResult',
            dataWorker__pb2.BrokerTestProtocolData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetConfig = channel.unary_unary(
                '/coinlib.FeatureWorker/GetConfig',
                request_serializer=dataWorker__pb2.WorkerJob.SerializeToString,
                response_deserializer=dataWorker__pb2.FeatureWorkerConfig.FromString,
                )
        self.OnErrorOccured = channel.unary_unary(
                '/coinlib.FeatureWorker/OnErrorOccured',
                request_serializer=dataWorker__pb2.FeatureError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.WatchCommands = channel.stream_stream(
                '/coinlib.FeatureWorker/WatchCommands',
                request_serializer=dataWorker__pb2.FeatureCommands.SerializeToString,
                response_deserializer=dataWorker__pb2.FeatureCommands.FromString,
                )
        self.SendCommandAnswer = channel.unary_unary(
                '/coinlib.FeatureWorker/SendCommandAnswer',
                request_serializer=dataWorker__pb2.FeatureCommandsAnswer.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.SendCommandAnswerError = channel.unary_unary(
                '/coinlib.FeatureWorker/SendCommandAnswerError',
                request_serializer=dataWorker__pb2.FeatureCommandsAnswerError.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.RegisterSession = channel.unary_unary(
                '/coinlib.FeatureWorker/RegisterSession',
                request_serializer=dataWorker__pb2.FeatureSessionRegistration.SerializeToString,
                response_deserializer=dataWorker__pb2.RegistrationInformation.FromString,
                )
        self.OnEvent = channel.unary_unary(
                '/coinlib.FeatureWorker/OnEvent',
                request_serializer=dataWorker__pb2.FeatureEventData.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def GetConfig(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 OnErrorOccured(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 WatchCommands(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 SendCommandAnswer(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 SendCommandAnswerError(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 RegisterSession(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 OnEvent(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_FeatureWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConfig,
                    request_deserializer=dataWorker__pb2.WorkerJob.FromString,
                    response_serializer=dataWorker__pb2.FeatureWorkerConfig.SerializeToString,
            ),
            'OnErrorOccured': grpc.unary_unary_rpc_method_handler(
                    servicer.OnErrorOccured,
                    request_deserializer=dataWorker__pb2.FeatureError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'WatchCommands': grpc.stream_stream_rpc_method_handler(
                    servicer.WatchCommands,
                    request_deserializer=dataWorker__pb2.FeatureCommands.FromString,
                    response_serializer=dataWorker__pb2.FeatureCommands.SerializeToString,
            ),
            'SendCommandAnswer': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommandAnswer,
                    request_deserializer=dataWorker__pb2.FeatureCommandsAnswer.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'SendCommandAnswerError': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommandAnswerError,
                    request_deserializer=dataWorker__pb2.FeatureCommandsAnswerError.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'RegisterSession': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterSession,
                    request_deserializer=dataWorker__pb2.FeatureSessionRegistration.FromString,
                    response_serializer=dataWorker__pb2.RegistrationInformation.SerializeToString,
            ),
            'OnEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.OnEvent,
                    request_deserializer=dataWorker__pb2.FeatureEventData.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.FeatureWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @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, '/coinlib.FeatureWorker/GetConfig',
            dataWorker__pb2.WorkerJob.SerializeToString,
            dataWorker__pb2.FeatureWorkerConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnErrorOccured(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, '/coinlib.FeatureWorker/OnErrorOccured',
            dataWorker__pb2.FeatureError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WatchCommands(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, '/coinlib.FeatureWorker/WatchCommands',
            dataWorker__pb2.FeatureCommands.SerializeToString,
            dataWorker__pb2.FeatureCommands.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendCommandAnswer(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, '/coinlib.FeatureWorker/SendCommandAnswer',
            dataWorker__pb2.FeatureCommandsAnswer.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendCommandAnswerError(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, '/coinlib.FeatureWorker/SendCommandAnswerError',
            dataWorker__pb2.FeatureCommandsAnswerError.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterSession(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, '/coinlib.FeatureWorker/RegisterSession',
            dataWorker__pb2.FeatureSessionRegistration.SerializeToString,
            dataWorker__pb2.RegistrationInformation.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OnEvent(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, '/coinlib.FeatureWorker/OnEvent',
            dataWorker__pb2.FeatureEventData.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerSymbolBroker = channel.unary_unary(
                '/coinlib.Symbol/registerSymbolBroker',
                request_serializer=dataWorker__pb2.SymbolBrokerRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerSymbolBroker(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_SymbolServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerSymbolBroker': grpc.unary_unary_rpc_method_handler(
                    servicer.registerSymbolBroker,
                    request_deserializer=dataWorker__pb2.SymbolBrokerRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Symbol', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerSymbolBroker(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, '/coinlib.Symbol/registerSymbolBroker',
            dataWorker__pb2.SymbolBrokerRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.getAllSymbols = channel.unary_unary(
                '/coinlib.DataLoaderWorker/getAllSymbols',
                request_serializer=dataWorker__pb2.SymbolDataRequestInfo.SerializeToString,
                response_deserializer=dataWorker__pb2.SymbolDataResponse.FromString,
                )
        self.getAllExchanges = channel.unary_unary(
                '/coinlib.DataLoaderWorker/getAllExchanges',
                request_serializer=dataWorker__pb2.ExchangeDataRequestInfo.SerializeToString,
                response_deserializer=dataWorker__pb2.ExchangeDataResponse.FromString,
                )
        self.getMarketData = channel.unary_unary(
                '/coinlib.DataLoaderWorker/getMarketData',
                request_serializer=dataWorker__pb2.MarketDataRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.MarketDataResponse.FromString,
                )
        self.getFeatureData = channel.unary_unary(
                '/coinlib.DataLoaderWorker/getFeatureData',
                request_serializer=dataWorker__pb2.FeatureDataRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.FeatureDataResponse.FromString,
                )
        self.getAdditionalDataFeatures = channel.unary_unary(
                '/coinlib.DataLoaderWorker/getAdditionalDataFeatures',
                request_serializer=dataWorker__pb2.AdditionalDataFeatureRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.AdditionalDataFeatureResponse.FromString,
                )


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

    def getAllSymbols(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 getAllExchanges(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 getMarketData(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 getFeatureData(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 getAdditionalDataFeatures(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_DataLoaderWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'getAllSymbols': grpc.unary_unary_rpc_method_handler(
                    servicer.getAllSymbols,
                    request_deserializer=dataWorker__pb2.SymbolDataRequestInfo.FromString,
                    response_serializer=dataWorker__pb2.SymbolDataResponse.SerializeToString,
            ),
            'getAllExchanges': grpc.unary_unary_rpc_method_handler(
                    servicer.getAllExchanges,
                    request_deserializer=dataWorker__pb2.ExchangeDataRequestInfo.FromString,
                    response_serializer=dataWorker__pb2.ExchangeDataResponse.SerializeToString,
            ),
            'getMarketData': grpc.unary_unary_rpc_method_handler(
                    servicer.getMarketData,
                    request_deserializer=dataWorker__pb2.MarketDataRequest.FromString,
                    response_serializer=dataWorker__pb2.MarketDataResponse.SerializeToString,
            ),
            'getFeatureData': grpc.unary_unary_rpc_method_handler(
                    servicer.getFeatureData,
                    request_deserializer=dataWorker__pb2.FeatureDataRequest.FromString,
                    response_serializer=dataWorker__pb2.FeatureDataResponse.SerializeToString,
            ),
            'getAdditionalDataFeatures': grpc.unary_unary_rpc_method_handler(
                    servicer.getAdditionalDataFeatures,
                    request_deserializer=dataWorker__pb2.AdditionalDataFeatureRequest.FromString,
                    response_serializer=dataWorker__pb2.AdditionalDataFeatureResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.DataLoaderWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def getAllSymbols(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, '/coinlib.DataLoaderWorker/getAllSymbols',
            dataWorker__pb2.SymbolDataRequestInfo.SerializeToString,
            dataWorker__pb2.SymbolDataResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def getAllExchanges(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, '/coinlib.DataLoaderWorker/getAllExchanges',
            dataWorker__pb2.ExchangeDataRequestInfo.SerializeToString,
            dataWorker__pb2.ExchangeDataResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def getMarketData(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, '/coinlib.DataLoaderWorker/getMarketData',
            dataWorker__pb2.MarketDataRequest.SerializeToString,
            dataWorker__pb2.MarketDataResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def getFeatureData(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, '/coinlib.DataLoaderWorker/getFeatureData',
            dataWorker__pb2.FeatureDataRequest.SerializeToString,
            dataWorker__pb2.FeatureDataResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def getAdditionalDataFeatures(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, '/coinlib.DataLoaderWorker/getAdditionalDataFeatures',
            dataWorker__pb2.AdditionalDataFeatureRequest.SerializeToString,
            dataWorker__pb2.AdditionalDataFeatureResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerNotification = channel.unary_unary(
                '/coinlib.Notification/registerNotification',
                request_serializer=dataWorker__pb2.NotificationRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerNotification(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_NotificationServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerNotification': grpc.unary_unary_rpc_method_handler(
                    servicer.registerNotification,
                    request_deserializer=dataWorker__pb2.NotificationRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Notification', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerNotification(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, '/coinlib.Notification/registerNotification',
            dataWorker__pb2.NotificationRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerFeature = channel.unary_unary(
                '/coinlib.Features/registerFeature',
                request_serializer=dataWorker__pb2.FeatureRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerFeature(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_FeaturesServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerFeature': grpc.unary_unary_rpc_method_handler(
                    servicer.registerFeature,
                    request_deserializer=dataWorker__pb2.FeatureRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Features', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerFeature(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, '/coinlib.Features/registerFeature',
            dataWorker__pb2.FeatureRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.registerStatisticRuleFunction = channel.unary_unary(
                '/coinlib.Statistics/registerStatisticRuleFunction',
                request_serializer=dataWorker__pb2.StatisticRuleFunctionRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.registerStatisticMethod = channel.unary_unary(
                '/coinlib.Statistics/registerStatisticMethod',
                request_serializer=dataWorker__pb2.StatisticMethodRegistration.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )


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

    def registerStatisticRuleFunction(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 registerStatisticMethod(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_StatisticsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'registerStatisticRuleFunction': grpc.unary_unary_rpc_method_handler(
                    servicer.registerStatisticRuleFunction,
                    request_deserializer=dataWorker__pb2.StatisticRuleFunctionRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'registerStatisticMethod': grpc.unary_unary_rpc_method_handler(
                    servicer.registerStatisticMethod,
                    request_deserializer=dataWorker__pb2.StatisticMethodRegistration.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.Statistics', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def registerStatisticRuleFunction(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, '/coinlib.Statistics/registerStatisticRuleFunction',
            dataWorker__pb2.StatisticRuleFunctionRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def registerStatisticMethod(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, '/coinlib.Statistics/registerStatisticMethod',
            dataWorker__pb2.StatisticMethodRegistration.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.getAllDataWorkerServer = channel.unary_unary(
                '/coinlib.DataWorkerRegistry/getAllDataWorkerServer',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.getDataWorkerServerEndpoint = channel.unary_unary(
                '/coinlib.DataWorkerRegistry/getDataWorkerServerEndpoint',
                request_serializer=dataWorker__pb2.WorkerRegistryRequest.SerializeToString,
                response_deserializer=dataWorker__pb2.WorkerRegistryResponse.FromString,
                )


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

    def getAllDataWorkerServer(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 getDataWorkerServerEndpoint(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_DataWorkerRegistryServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'getAllDataWorkerServer': grpc.unary_unary_rpc_method_handler(
                    servicer.getAllDataWorkerServer,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'getDataWorkerServerEndpoint': grpc.unary_unary_rpc_method_handler(
                    servicer.getDataWorkerServerEndpoint,
                    request_deserializer=dataWorker__pb2.WorkerRegistryRequest.FromString,
                    response_serializer=dataWorker__pb2.WorkerRegistryResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'coinlib.DataWorkerRegistry', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def getAllDataWorkerServer(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, '/coinlib.DataWorkerRegistry/getAllDataWorkerServer',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def getDataWorkerServerEndpoint(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, '/coinlib.DataWorkerRegistry/getDataWorkerServerEndpoint',
            dataWorker__pb2.WorkerRegistryRequest.SerializeToString,
            dataWorker__pb2.WorkerRegistryResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
