ccxt 4.3.95__py2.py3-none-any.whl → 4.3.96__py2.py3-none-any.whl

ccxt/pro/bybit.py

@@ -609,6 +609,53 @@ class bybit(ccxt.async_support.bybit):
         filtered = self.filter_by_since_limit(stored, since, limit, 0, True)
         return self.create_ohlcv_object(symbol, timeframe, filtered)
 
+    async def un_watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], params={}):
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/kline
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/etp-kline
+        :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        symbols = self.get_list_from_object_values(symbolsAndTimeframes, 0)
+        marketSymbols = self.market_symbols(symbols, None, False, True, True)
+        firstSymbol = marketSymbols[0]
+        url = await self.get_url_by_market_type(firstSymbol, False, 'watchOHLCVForSymbols', params)
+        rawHashes = []
+        subMessageHashes = []
+        messageHashes = []
+        for i in range(0, len(symbolsAndTimeframes)):
+            data = symbolsAndTimeframes[i]
+            symbolString = self.safe_string(data, 0)
+            market = self.market(symbolString)
+            symbolString = market['symbol']
+            unfiedTimeframe = self.safe_string(data, 1)
+            timeframeId = self.safe_string(self.timeframes, unfiedTimeframe, unfiedTimeframe)
+            rawHashes.append('kline.' + timeframeId + '.' + market['id'])
+            subMessageHashes.append('ohlcv::' + symbolString + '::' + unfiedTimeframe)
+            messageHashes.append('unsubscribe::ohlcv::' + symbolString + '::' + unfiedTimeframe)
+        subExtension = {
+            'symbolsAndTimeframes': symbolsAndTimeframes,
+        }
+        return await self.un_watch_topics(url, 'ohlcv', symbols, messageHashes, subMessageHashes, rawHashes, params, subExtension)
+
+    async def un_watch_ohlcv(self, symbol: str, timeframe='1m', params={}) -> Any:
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/kline
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/etp-kline
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        params['callerMethodName'] = 'watchOHLCV'
+        return await self.un_watch_ohlcv_for_symbols([[symbol, timeframe]], params)
+
     def handle_ohlcv(self, client: Client, message):
         #
         #     {
@@ -1997,7 +2044,7 @@ class bybit(ccxt.async_support.bybit):
         message = self.extend(request, params)
         return await self.watch_multiple(url, messageHashes, message, messageHashes)
 
-    async def un_watch_topics(self, url: str, topic: str, symbols: List[str], messageHashes: List[str], subMessageHashes: List[str], topics, params={}):
+    async def un_watch_topics(self, url: str, topic: str, symbols: List[str], messageHashes: List[str], subMessageHashes: List[str], topics, params={}, subExtension={}):
         reqId = self.request_id()
         request: dict = {
             'op': 'unsubscribe',
@@ -2012,7 +2059,7 @@ class bybit(ccxt.async_support.bybit):
             'symbols': symbols,
         }
         message = self.extend(request, params)
-        return await self.watch_multiple(url, messageHashes, message, messageHashes, subscription)
+        return await self.watch_multiple(url, messageHashes, message, messageHashes, self.extend(subscription, subExtension))
 
     async def authenticate(self, url, params={}):
         self.check_required_credentials()
@@ -2270,14 +2317,21 @@ class bybit(ccxt.async_support.bybit):
                     error = UnsubscribeError(self.id + ' ' + messageHash)
                     client.reject(error, subHash)
                     client.resolve(True, unsubHash)
-                    self.clean_cache(subscription)
+                self.clean_cache(subscription)
         return message
 
     def clean_cache(self, subscription: dict):
         topic = self.safe_string(subscription, 'topic')
         symbols = self.safe_list(subscription, 'symbols', [])
         symbolsLength = len(symbols)
-        if symbolsLength > 0:
+        if topic == 'ohlcv':
+            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
+            for i in range(0, len(symbolsAndTimeFrames)):
+                symbolAndTimeFrame = symbolsAndTimeFrames[i]
+                symbol = self.safe_string(symbolAndTimeFrame, 0)
+                timeframe = self.safe_string(symbolAndTimeFrame, 1)
+                del self.ohlcvs[symbol][timeframe]
+        elif symbolsLength > 0:
             for i in range(0, len(symbols)):
                 symbol = symbols[i]
                 if topic == 'trade':

ccxt/pro/cryptocom.py

@@ -9,10 +9,12 @@ import hashlib
 from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from typing import Any
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import NetworkError
 from ccxt.base.errors import ChecksumError
+from ccxt.base.errors import UnsubscribeError
 
 
 class cryptocom(ccxt.async_support.cryptocom):
@@ -86,6 +88,18 @@ class cryptocom(ccxt.async_support.cryptocom):
         """
         return await self.watch_order_book_for_symbols([symbol], limit, params)
 
+    async def un_watch_order_book(self, symbol: str, params={}) -> Any:
+        """
+        unWatches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#book-instrument_name
+        :param str symbol: unified symbol of the market to fetch the order book for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.bookSubscriptionType]: The subscription type. Allowed values: SNAPSHOT full snapshot. This is the default if not specified. SNAPSHOT_AND_UPDATE delta updates
+        :param int [params.bookUpdateFrequency]: Book update interval in ms. Allowed values: 100 for snapshot subscription 10 for delta subscription
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        return await self.un_watch_order_book_for_symbols([symbol], params)
+
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
@@ -127,6 +141,47 @@ class cryptocom(ccxt.async_support.cryptocom):
         orderbook = await self.watch_public_multiple(messageHashes, topics, params)
         return orderbook.limit()
 
+    async def un_watch_order_book_for_symbols(self, symbols: List[str], params={}) -> OrderBook:
+        """
+        unWatches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#book-instrument_name
+        :param str[] symbols: unified array of symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.limit]: orderbook limit, default is 50
+        :param str [params.bookSubscriptionType]: The subscription type. Allowed values: SNAPSHOT full snapshot. This is the default if not specified. SNAPSHOT_AND_UPDATE delta updates
+        :param int [params.bookUpdateFrequency]: Book update interval in ms. Allowed values: 100 for snapshot subscription 10 for delta subscription
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        topics = []
+        subMessageHashes = []
+        messageHashes = []
+        limit = self.safe_integer(params, 'limit', 50)
+        topicParams = self.safe_value(params, 'params')
+        if topicParams is None:
+            params['params'] = {}
+        bookSubscriptionType = None
+        bookSubscriptionType2 = None
+        bookSubscriptionType, params = self.handle_option_and_params(params, 'watchOrderBook', 'bookSubscriptionType', 'SNAPSHOT_AND_UPDATE')
+        bookSubscriptionType2, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'bookSubscriptionType', bookSubscriptionType)
+        params['params']['bookSubscriptionType'] = bookSubscriptionType2
+        bookUpdateFrequency = None
+        bookUpdateFrequency2 = None
+        bookUpdateFrequency, params = self.handle_option_and_params(params, 'watchOrderBook', 'bookUpdateFrequency')
+        bookUpdateFrequency2, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'bookUpdateFrequency', bookUpdateFrequency)
+        if bookUpdateFrequency2 is not None:
+            params['params']['bookSubscriptionType'] = bookUpdateFrequency2
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            currentTopic = 'book' + '.' + market['id'] + '.' + str(limit)
+            messageHash = 'orderbook:' + market['symbol']
+            subMessageHashes.append(messageHash)
+            messageHashes.append('unsubscribe:' + messageHash)
+            topics.append(currentTopic)
+        return await self.un_watch_public_multiple('orderbook', symbols, messageHashes, subMessageHashes, topics, params)
+
     def handle_delta(self, bookside, delta):
         price = self.safe_float(delta, 0)
         amount = self.safe_float(delta, 1)
@@ -239,6 +294,18 @@ class cryptocom(ccxt.async_support.cryptocom):
         """
         return await self.watch_trades_for_symbols([symbol], since, limit, params)
 
+    async def un_watch_trades(self, symbol: str, params={}) -> List[Trade]:
+        """
+        get the list of most recent trades for a particular symbol
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#trade-instrument_name
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param int [since]: timestamp in ms of the earliest trade to fetch
+        :param int [limit]: the maximum amount of trades to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        return await self.un_watch_trades_for_symbols([symbol], params)
+
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
@@ -264,6 +331,26 @@ class cryptocom(ccxt.async_support.cryptocom):
             limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def un_watch_trades_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        get the list of most recent trades for a particular symbol
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#trade-instrument_name
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        topics = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            currentTopic = 'trade' + '.' + market['id']
+            messageHashes.append('unsubscribe:trades:' + market['symbol'])
+            topics.append(currentTopic)
+        return await self.un_watch_public_multiple('trade', symbols, messageHashes, topics, topics, params)
+
     def handle_trades(self, client: Client, message):
         #
         # {
@@ -343,6 +430,20 @@ class cryptocom(ccxt.async_support.cryptocom):
         messageHash = 'ticker' + '.' + market['id']
         return await self.watch_public(messageHash, params)
 
+    async def un_watch_ticker(self, symbol: str, params={}) -> Any:
+        """
+        unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+        :param str symbol: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        subMessageHash = 'ticker' + '.' + market['id']
+        messageHash = 'unsubscribe:ticker:' + market['symbol']
+        return await self.un_watch_public_multiple('ticker', [market['symbol']], [messageHash], [subMessageHash], [subMessageHash], params)
+
     def handle_ticker(self, client: Client, message):
         #
         # {
@@ -398,6 +499,26 @@ class cryptocom(ccxt.async_support.cryptocom):
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
+    async def un_watch_ohlcv(self, symbol: str, timeframe='1m', params={}) -> Any:
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#candlestick-time_frame-instrument_name
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        interval = self.safe_string(self.timeframes, timeframe, timeframe)
+        subMessageHash = 'candlestick' + '.' + interval + '.' + market['id']
+        messageHash = 'unsubscribe:ohlcv:' + market['symbol'] + ':' + timeframe
+        subExtend = {
+            'symbolsAndTimeframes': [[market['symbol'], timeframe]],
+        }
+        return await self.un_watch_public_multiple('ohlcv', [market['symbol']], [messageHash], [subMessageHash], [subMessageHash], params, subExtend)
+
     def handle_ohlcv(self, client: Client, message):
         #
         #  {
@@ -795,6 +916,27 @@ class cryptocom(ccxt.async_support.cryptocom):
         message = self.deep_extend(request, params)
         return await self.watch_multiple(url, messageHashes, message, messageHashes)
 
+    async def un_watch_public_multiple(self, topic: str, symbols: List[str], messageHashes: List[str], subMessageHashes: List[str], topics: List[str], params={}, subExtend={}):
+        url = self.urls['api']['ws']['public']
+        id = self.nonce()
+        request: dict = {
+            'method': 'unsubscribe',
+            'params': {
+                'channels': topics,
+            },
+            'nonce': id,
+            'id': str(id),
+        }
+        subscription = {
+            'id': str(id),
+            'topic': topic,
+            'symbols': symbols,
+            'subMessageHashes': subMessageHashes,
+            'messageHashes': messageHashes,
+        }
+        message = self.deep_extend(request, params)
+        return await self.watch_multiple(url, messageHashes, message, messageHashes, self.extend(subscription, subExtend))
+
     async def watch_private_request(self, nonce, params={}):
         await self.authenticate()
         url = self.urls['api']['ws']['private']
@@ -904,6 +1046,9 @@ class cryptocom(ccxt.async_support.cryptocom):
         #           "channel":"ticker",
         #           "data":[{}]
         #
+        # handle unsubscribe
+        # {"id":1725448572836,"method":"unsubscribe","code":0}
+        #
         if self.handle_error_message(client, message):
             return
         method = self.safe_string(message, 'method')
@@ -916,6 +1061,7 @@ class cryptocom(ccxt.async_support.cryptocom):
             'private/cancel-all-orders': self.handle_cancel_all_orders,
             'private/close-position': self.handle_order,
             'subscribe': self.handle_subscribe,
+            'unsubscribe': self.handle_unsubscribe,
         }
         callMethod = self.safe_value(methods, method)
         if callMethod is not None:
@@ -953,3 +1099,52 @@ class cryptocom(ccxt.async_support.cryptocom):
         #
         future = self.safe_value(client.futures, 'authenticated')
         future.resolve(True)
+
+    def handle_unsubscribe(self, client: Client, message):
+        id = self.safe_string(message, 'id')
+        keys = list(client.subscriptions.keys())
+        for i in range(0, len(keys)):
+            messageHash = keys[i]
+            if not (messageHash in client.subscriptions):
+                continue
+                # the previous iteration can have deleted the messageHash from the subscriptions
+            if messageHash.startswith('unsubscribe'):
+                subscription = client.subscriptions[messageHash]
+                subId = self.safe_string(subscription, 'id')
+                if id != subId:
+                    continue
+                messageHashes = self.safe_list(subscription, 'messageHashes', [])
+                subMessageHashes = self.safe_list(subscription, 'subMessageHashes', [])
+                for j in range(0, len(messageHashes)):
+                    unsubHash = messageHashes[j]
+                    subHash = subMessageHashes[j]
+                    if unsubHash in client.subscriptions:
+                        del client.subscriptions[unsubHash]
+                    if subHash in client.subscriptions:
+                        del client.subscriptions[subHash]
+                    error = UnsubscribeError(self.id + ' ' + subHash)
+                    client.reject(error, subHash)
+                    client.resolve(True, unsubHash)
+                self.clean_cache(subscription)
+
+    def clean_cache(self, subscription: dict):
+        topic = self.safe_string(subscription, 'topic')
+        symbols = self.safe_list(subscription, 'symbols', [])
+        symbolsLength = len(symbols)
+        if topic == 'ohlcv':
+            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
+            for i in range(0, len(symbolsAndTimeFrames)):
+                symbolAndTimeFrame = symbolsAndTimeFrames[i]
+                symbol = self.safe_string(symbolAndTimeFrame, 0)
+                timeframe = self.safe_string(symbolAndTimeFrame, 1)
+                if timeframe in self.ohlcvs[symbol]:
+                    del self.ohlcvs[symbol][timeframe]
+        elif symbolsLength > 0:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                if topic == 'trade':
+                    del self.trades[symbol]
+                elif topic == 'orderbook':
+                    del self.orderbooks[symbol]
+                elif topic == 'ticker':
+                    del self.tickers[symbol]