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

from kaikosdk.stream.aggregated_price_v1 import request_pb2 as sdk_dot_stream_dot_aggregated__price__v1_dot_request__pb2
from kaikosdk.stream.aggregated_price_v1 import response_pb2 as sdk_dot_stream_dot_aggregated__price__v1_dot_response__pb2
from kaikosdk.stream.aggregated_quote_v2 import request_pb2 as sdk_dot_stream_dot_aggregated__quote__v2_dot_request__pb2
from kaikosdk.stream.aggregated_quote_v2 import response_pb2 as sdk_dot_stream_dot_aggregated__quote__v2_dot_response__pb2
from kaikosdk.stream.aggregates_direct_exchange_rate_v2 import request_pb2 as sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_request__pb2
from kaikosdk.stream.aggregates_direct_exchange_rate_v2 import response_pb2 as sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_response__pb2
from kaikosdk.stream.aggregates_ohlcv_v1 import request_pb2 as sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_request__pb2
from kaikosdk.stream.aggregates_ohlcv_v1 import response_pb2 as sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_response__pb2
from kaikosdk.stream.aggregates_spot_exchange_rate_v2 import request_pb2 as sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_request__pb2
from kaikosdk.stream.aggregates_spot_exchange_rate_v2 import response_pb2 as sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_response__pb2
from kaikosdk.stream.aggregates_vwap_v1 import request_pb2 as sdk_dot_stream_dot_aggregates__vwap__v1_dot_request__pb2
from kaikosdk.stream.aggregates_vwap_v1 import response_pb2 as sdk_dot_stream_dot_aggregates__vwap__v1_dot_response__pb2
from kaikosdk.stream.derivatives_instrument_metrics_v1 import request_pb2 as sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_request__pb2
from kaikosdk.stream.derivatives_instrument_metrics_v1 import response_pb2 as sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_response__pb2
from kaikosdk.stream.exotic_indices_v1 import request_pb2 as sdk_dot_stream_dot_exotic__indices__v1_dot_request__pb2
from kaikosdk.stream.exotic_indices_v1 import response_pb2 as sdk_dot_stream_dot_exotic__indices__v1_dot_response__pb2
from kaikosdk.stream.index_forex_rate_v1 import request_pb2 as sdk_dot_stream_dot_index__forex__rate__v1_dot_request__pb2
from kaikosdk.stream.index_forex_rate_v1 import response_pb2 as sdk_dot_stream_dot_index__forex__rate__v1_dot_response__pb2
from kaikosdk.stream.index_multi_assets_v1 import request_pb2 as sdk_dot_stream_dot_index__multi__assets__v1_dot_request__pb2
from kaikosdk.stream.index_multi_assets_v1 import response_pb2 as sdk_dot_stream_dot_index__multi__assets__v1_dot_response__pb2
from kaikosdk.stream.index_v1 import request_pb2 as sdk_dot_stream_dot_index__v1_dot_request__pb2
from kaikosdk.stream.index_v1 import response_pb2 as sdk_dot_stream_dot_index__v1_dot_response__pb2
from kaikosdk.stream.iv_svi_parameters_v1 import request_pb2 as sdk_dot_stream_dot_iv__svi__parameters__v1_dot_request__pb2
from kaikosdk.stream.iv_svi_parameters_v1 import response_pb2 as sdk_dot_stream_dot_iv__svi__parameters__v1_dot_response__pb2
from kaikosdk.stream.market_update_v1 import request_pb2 as sdk_dot_stream_dot_market__update__v1_dot_request__pb2
from kaikosdk.stream.market_update_v1 import response_pb2 as sdk_dot_stream_dot_market__update__v1_dot_response__pb2
from kaikosdk.stream.trades_v1 import request_pb2 as sdk_dot_stream_dot_trades__v1_dot_request__pb2
from kaikosdk.stream.trades_v1 import response_pb2 as sdk_dot_stream_dot_trades__v1_dot_response__pb2


class StreamAggregatedQuoteServiceV2Stub(object):
    """Service for streaming Aggregated Quote V2
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamAggregatedQuoteServiceV2/Subscribe',
                request_serializer=sdk_dot_stream_dot_aggregated__quote__v2_dot_request__pb2.StreamAggregatedQuoteRequestV2.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_aggregated__quote__v2_dot_response__pb2.StreamAggregatedQuoteResponseV2.FromString,
                )


class StreamAggregatedQuoteServiceV2Servicer(object):
    """Service for streaming Aggregated Quote V2
    """

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


def add_StreamAggregatedQuoteServiceV2Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_aggregated__quote__v2_dot_request__pb2.StreamAggregatedQuoteRequestV2.FromString,
                    response_serializer=sdk_dot_stream_dot_aggregated__quote__v2_dot_response__pb2.StreamAggregatedQuoteResponseV2.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamAggregatedQuoteServiceV2', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamAggregatedQuoteServiceV2(object):
    """Service for streaming Aggregated Quote V2
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamAggregatedQuoteServiceV2/Subscribe',
            sdk_dot_stream_dot_aggregated__quote__v2_dot_request__pb2.StreamAggregatedQuoteRequestV2.SerializeToString,
            sdk_dot_stream_dot_aggregated__quote__v2_dot_response__pb2.StreamAggregatedQuoteResponseV2.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamAggregatedPriceServiceV1Stub(object):
    """Service for streaming Aggregated Price V1
    Service is deprecated, use `StreamAggregatedQuoteServiceV1` instead.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamAggregatedPriceServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_aggregated__price__v1_dot_request__pb2.StreamAggregatedPriceRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_aggregated__price__v1_dot_response__pb2.StreamAggregatedPriceResponseV1.FromString,
                )


class StreamAggregatedPriceServiceV1Servicer(object):
    """Service for streaming Aggregated Price V1
    Service is deprecated, use `StreamAggregatedQuoteServiceV1` instead.
    """

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


def add_StreamAggregatedPriceServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_aggregated__price__v1_dot_request__pb2.StreamAggregatedPriceRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_aggregated__price__v1_dot_response__pb2.StreamAggregatedPriceResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamAggregatedPriceServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamAggregatedPriceServiceV1(object):
    """Service for streaming Aggregated Price V1
    Service is deprecated, use `StreamAggregatedQuoteServiceV1` instead.
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamAggregatedPriceServiceV1/Subscribe',
            sdk_dot_stream_dot_aggregated__price__v1_dot_request__pb2.StreamAggregatedPriceRequestV1.SerializeToString,
            sdk_dot_stream_dot_aggregated__price__v1_dot_response__pb2.StreamAggregatedPriceResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamAggregatesOHLCVServiceV1Stub(object):
    """Service for streaming OHLCV V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamAggregatesOHLCVServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_request__pb2.StreamAggregatesOHLCVRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_response__pb2.StreamAggregatesOHLCVResponseV1.FromString,
                )


class StreamAggregatesOHLCVServiceV1Servicer(object):
    """Service for streaming OHLCV V1
    """

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


def add_StreamAggregatesOHLCVServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_request__pb2.StreamAggregatesOHLCVRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_response__pb2.StreamAggregatesOHLCVResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamAggregatesOHLCVServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamAggregatesOHLCVServiceV1(object):
    """Service for streaming OHLCV V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamAggregatesOHLCVServiceV1/Subscribe',
            sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_request__pb2.StreamAggregatesOHLCVRequestV1.SerializeToString,
            sdk_dot_stream_dot_aggregates__ohlcv__v1_dot_response__pb2.StreamAggregatesOHLCVResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamTradesServiceV1Stub(object):
    """Service for streaming trades V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamTradesServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_trades__v1_dot_request__pb2.StreamTradesRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_trades__v1_dot_response__pb2.StreamTradesResponseV1.FromString,
                )


class StreamTradesServiceV1Servicer(object):
    """Service for streaming trades V1
    """

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


def add_StreamTradesServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_trades__v1_dot_request__pb2.StreamTradesRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_trades__v1_dot_response__pb2.StreamTradesResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamTradesServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamTradesServiceV1(object):
    """Service for streaming trades V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamTradesServiceV1/Subscribe',
            sdk_dot_stream_dot_trades__v1_dot_request__pb2.StreamTradesRequestV1.SerializeToString,
            sdk_dot_stream_dot_trades__v1_dot_response__pb2.StreamTradesResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamAggregatesVWAPServiceV1Stub(object):
    """Service for streaming VWAP V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamAggregatesVWAPServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_aggregates__vwap__v1_dot_request__pb2.StreamAggregatesVWAPRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_aggregates__vwap__v1_dot_response__pb2.StreamAggregatesVWAPResponseV1.FromString,
                )


class StreamAggregatesVWAPServiceV1Servicer(object):
    """Service for streaming VWAP V1
    """

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


def add_StreamAggregatesVWAPServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_aggregates__vwap__v1_dot_request__pb2.StreamAggregatesVWAPRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_aggregates__vwap__v1_dot_response__pb2.StreamAggregatesVWAPResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamAggregatesVWAPServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamAggregatesVWAPServiceV1(object):
    """Service for streaming VWAP V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamAggregatesVWAPServiceV1/Subscribe',
            sdk_dot_stream_dot_aggregates__vwap__v1_dot_request__pb2.StreamAggregatesVWAPRequestV1.SerializeToString,
            sdk_dot_stream_dot_aggregates__vwap__v1_dot_response__pb2.StreamAggregatesVWAPResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamIndexServiceV1Stub(object):
    """Service for streaming index V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamIndexServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_index__v1_dot_request__pb2.StreamIndexServiceRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_index__v1_dot_response__pb2.StreamIndexServiceResponseV1.FromString,
                )


class StreamIndexServiceV1Servicer(object):
    """Service for streaming index V1
    """

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


def add_StreamIndexServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_index__v1_dot_request__pb2.StreamIndexServiceRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_index__v1_dot_response__pb2.StreamIndexServiceResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamIndexServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamIndexServiceV1(object):
    """Service for streaming index V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamIndexServiceV1/Subscribe',
            sdk_dot_stream_dot_index__v1_dot_request__pb2.StreamIndexServiceRequestV1.SerializeToString,
            sdk_dot_stream_dot_index__v1_dot_response__pb2.StreamIndexServiceResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamIndexMultiAssetsServiceV1Stub(object):
    """Service for streaming index multi assets V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamIndexMultiAssetsServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_index__multi__assets__v1_dot_request__pb2.StreamIndexMultiAssetsServiceRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_index__multi__assets__v1_dot_response__pb2.StreamIndexMultiAssetsServiceResponseV1.FromString,
                )


class StreamIndexMultiAssetsServiceV1Servicer(object):
    """Service for streaming index multi assets V1
    """

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


def add_StreamIndexMultiAssetsServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_index__multi__assets__v1_dot_request__pb2.StreamIndexMultiAssetsServiceRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_index__multi__assets__v1_dot_response__pb2.StreamIndexMultiAssetsServiceResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamIndexMultiAssetsServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamIndexMultiAssetsServiceV1(object):
    """Service for streaming index multi assets V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamIndexMultiAssetsServiceV1/Subscribe',
            sdk_dot_stream_dot_index__multi__assets__v1_dot_request__pb2.StreamIndexMultiAssetsServiceRequestV1.SerializeToString,
            sdk_dot_stream_dot_index__multi__assets__v1_dot_response__pb2.StreamIndexMultiAssetsServiceResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamMarketUpdateServiceV1Stub(object):
    """Service for streaming market update V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamMarketUpdateServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_market__update__v1_dot_request__pb2.StreamMarketUpdateRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_market__update__v1_dot_response__pb2.StreamMarketUpdateResponseV1.FromString,
                )


class StreamMarketUpdateServiceV1Servicer(object):
    """Service for streaming market update V1
    """

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


def add_StreamMarketUpdateServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_market__update__v1_dot_request__pb2.StreamMarketUpdateRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_market__update__v1_dot_response__pb2.StreamMarketUpdateResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamMarketUpdateServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamMarketUpdateServiceV1(object):
    """Service for streaming market update V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamMarketUpdateServiceV1/Subscribe',
            sdk_dot_stream_dot_market__update__v1_dot_request__pb2.StreamMarketUpdateRequestV1.SerializeToString,
            sdk_dot_stream_dot_market__update__v1_dot_response__pb2.StreamMarketUpdateResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamAggregatesSpotExchangeRateV2ServiceV1Stub(object):
    """Service for streaming Spot exchange rate V2 service V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamAggregatesSpotExchangeRateV2ServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_request__pb2.StreamAggregatesSpotExchangeRateV2RequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_response__pb2.StreamAggregatesSpotExchangeRateV2ResponseV1.FromString,
                )


class StreamAggregatesSpotExchangeRateV2ServiceV1Servicer(object):
    """Service for streaming Spot exchange rate V2 service V1
    """

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


def add_StreamAggregatesSpotExchangeRateV2ServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_request__pb2.StreamAggregatesSpotExchangeRateV2RequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_response__pb2.StreamAggregatesSpotExchangeRateV2ResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamAggregatesSpotExchangeRateV2ServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamAggregatesSpotExchangeRateV2ServiceV1(object):
    """Service for streaming Spot exchange rate V2 service V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamAggregatesSpotExchangeRateV2ServiceV1/Subscribe',
            sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_request__pb2.StreamAggregatesSpotExchangeRateV2RequestV1.SerializeToString,
            sdk_dot_stream_dot_aggregates__spot__exchange__rate__v2_dot_response__pb2.StreamAggregatesSpotExchangeRateV2ResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamAggregatesSpotDirectExchangeRateV2ServiceV1Stub(object):
    """Service for streaming Direct exchange rate V2 service V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamAggregatesSpotDirectExchangeRateV2ServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_request__pb2.StreamAggregatesDirectExchangeRateV2RequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_response__pb2.StreamAggregatesDirectExchangeRateV2ResponseV1.FromString,
                )


class StreamAggregatesSpotDirectExchangeRateV2ServiceV1Servicer(object):
    """Service for streaming Direct exchange rate V2 service V1
    """

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


def add_StreamAggregatesSpotDirectExchangeRateV2ServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_request__pb2.StreamAggregatesDirectExchangeRateV2RequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_response__pb2.StreamAggregatesDirectExchangeRateV2ResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamAggregatesSpotDirectExchangeRateV2ServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamAggregatesSpotDirectExchangeRateV2ServiceV1(object):
    """Service for streaming Direct exchange rate V2 service V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamAggregatesSpotDirectExchangeRateV2ServiceV1/Subscribe',
            sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_request__pb2.StreamAggregatesDirectExchangeRateV2RequestV1.SerializeToString,
            sdk_dot_stream_dot_aggregates__direct__exchange__rate__v2_dot_response__pb2.StreamAggregatesDirectExchangeRateV2ResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamIndexForexRateServiceV1Stub(object):
    """Service for streaming index Forex rate assets V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamIndexForexRateServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_index__forex__rate__v1_dot_request__pb2.StreamIndexForexRateServiceRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_index__forex__rate__v1_dot_response__pb2.StreamIndexForexRateServiceResponseV1.FromString,
                )


class StreamIndexForexRateServiceV1Servicer(object):
    """Service for streaming index Forex rate assets V1
    """

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


def add_StreamIndexForexRateServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_index__forex__rate__v1_dot_request__pb2.StreamIndexForexRateServiceRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_index__forex__rate__v1_dot_response__pb2.StreamIndexForexRateServiceResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamIndexForexRateServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamIndexForexRateServiceV1(object):
    """Service for streaming index Forex rate assets V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamIndexForexRateServiceV1/Subscribe',
            sdk_dot_stream_dot_index__forex__rate__v1_dot_request__pb2.StreamIndexForexRateServiceRequestV1.SerializeToString,
            sdk_dot_stream_dot_index__forex__rate__v1_dot_response__pb2.StreamIndexForexRateServiceResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamDerivativesInstrumentMetricsServiceV1Stub(object):
    """Service for streaming derivatives instrument metrics V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamDerivativesInstrumentMetricsServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_request__pb2.StreamDerivativesInstrumentMetricsRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_response__pb2.StreamDerivativesInstrumentMetricsResponseV1.FromString,
                )


class StreamDerivativesInstrumentMetricsServiceV1Servicer(object):
    """Service for streaming derivatives instrument metrics V1
    """

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


def add_StreamDerivativesInstrumentMetricsServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_request__pb2.StreamDerivativesInstrumentMetricsRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_response__pb2.StreamDerivativesInstrumentMetricsResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamDerivativesInstrumentMetricsServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamDerivativesInstrumentMetricsServiceV1(object):
    """Service for streaming derivatives instrument metrics V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamDerivativesInstrumentMetricsServiceV1/Subscribe',
            sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_request__pb2.StreamDerivativesInstrumentMetricsRequestV1.SerializeToString,
            sdk_dot_stream_dot_derivatives__instrument__metrics__v1_dot_response__pb2.StreamDerivativesInstrumentMetricsResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamIvSviParametersServiceV1Stub(object):
    """Service for streaming IV SVI parameters V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamIvSviParametersServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_iv__svi__parameters__v1_dot_request__pb2.StreamIvSviParametersRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_iv__svi__parameters__v1_dot_response__pb2.StreamIvSviParametersResponseV1.FromString,
                )


class StreamIvSviParametersServiceV1Servicer(object):
    """Service for streaming IV SVI parameters V1
    """

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


def add_StreamIvSviParametersServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_iv__svi__parameters__v1_dot_request__pb2.StreamIvSviParametersRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_iv__svi__parameters__v1_dot_response__pb2.StreamIvSviParametersResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamIvSviParametersServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamIvSviParametersServiceV1(object):
    """Service for streaming IV SVI parameters V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamIvSviParametersServiceV1/Subscribe',
            sdk_dot_stream_dot_iv__svi__parameters__v1_dot_request__pb2.StreamIvSviParametersRequestV1.SerializeToString,
            sdk_dot_stream_dot_iv__svi__parameters__v1_dot_response__pb2.StreamIvSviParametersResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)


class StreamExoticIndicesServiceV1Stub(object):
    """Service for streaming Exotic Indices V1
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/kaikosdk.StreamExoticIndicesServiceV1/Subscribe',
                request_serializer=sdk_dot_stream_dot_exotic__indices__v1_dot_request__pb2.StreamExoticIndicesServiceRequestV1.SerializeToString,
                response_deserializer=sdk_dot_stream_dot_exotic__indices__v1_dot_response__pb2.StreamExoticIndicesServiceResponseV1.FromString,
                )


class StreamExoticIndicesServiceV1Servicer(object):
    """Service for streaming Exotic Indices V1
    """

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


def add_StreamExoticIndicesServiceV1Servicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=sdk_dot_stream_dot_exotic__indices__v1_dot_request__pb2.StreamExoticIndicesServiceRequestV1.FromString,
                    response_serializer=sdk_dot_stream_dot_exotic__indices__v1_dot_response__pb2.StreamExoticIndicesServiceResponseV1.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kaikosdk.StreamExoticIndicesServiceV1', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class StreamExoticIndicesServiceV1(object):
    """Service for streaming Exotic Indices V1
    """

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/kaikosdk.StreamExoticIndicesServiceV1/Subscribe',
            sdk_dot_stream_dot_exotic__indices__v1_dot_request__pb2.StreamExoticIndicesServiceRequestV1.SerializeToString,
            sdk_dot_stream_dot_exotic__indices__v1_dot_response__pb2.StreamExoticIndicesServiceResponseV1.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
