ccxt 4.2.95__py2.py3-none-any.whl → 4.2.97__py2.py3-none-any.whl

ccxt/deribit.py

@@ -1184,13 +1184,17 @@ class deribit(Exchange, ImplicitAPI):
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
         :see: https://docs.deribit.com/#public-get_book_summary_by_currency
-        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+        :param str[] [symbols]: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.code]: *required* the currency code to fetch the tickers for, eg. 'BTC', 'ETH'
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         self.load_markets()
         symbols = self.market_symbols(symbols)
-        code = self.code_from_options('fetchTickers', params)
+        code = self.safe_string_2(params, 'code', 'currency')
+        params = self.omit(params, ['code'])
+        if code is None:
+            raise ArgumentsRequired(self.id + ' fetchTickers requires a currency/code(eg: BTC/ETH/USDT) parameter to fetch tickers for')
         currency = self.currency(code)
         request = {
             'currency': currency['id'],
@@ -1226,7 +1230,7 @@ class deribit(Exchange, ImplicitAPI):
         #         "testnet": False
         #     }
         #
-        result = self.safe_value(response, 'result', [])
+        result = self.safe_list(response, 'result', [])
         tickers = {}
         for i in range(0, len(result)):
             ticker = self.parse_ticker(result[i])

ccxt/gemini.py

@@ -299,7 +299,13 @@ class gemini(Exchange, ImplicitAPI):
                     'ATOM': 'cosmos',
                     'DOT': 'polkadot',
                 },
-                'nonce': 'milliseconds',  # if getting a Network 400 error change to seconds
+                'nonce': 'milliseconds',  # if getting a Network 400 error change to seconds,
+                'conflictingMarkets': {
+                    'paxgusd': {
+                        'base': 'PAXG',
+                        'quote': 'USD',
+                    },
+                },
             },
         })
 
@@ -661,16 +667,25 @@ class gemini(Exchange, ImplicitAPI):
             marketIdUpper = marketId.upper()
             isPerp = (marketIdUpper.find('PERP') >= 0)
             marketIdWithoutPerp = marketIdUpper.replace('PERP', '')
-            quoteQurrencies = self.handle_option('fetchMarketsFromAPI', 'quoteCurrencies', [])
-            for i in range(0, len(quoteQurrencies)):
-                quoteCurrency = quoteQurrencies[i]
-                if marketIdWithoutPerp.endswith(quoteCurrency):
-                    quoteLength = self.parse_to_int(-1 * len(quoteCurrency))
-                    baseId = marketIdWithoutPerp[0:quoteLength]
-                    quoteId = quoteCurrency
-                    if isPerp:
-                        settleId = quoteCurrency  # always same
-                    break
+            conflictingMarkets = self.safe_dict(self.options, 'conflictingMarkets', {})
+            lowerCaseId = marketIdWithoutPerp.lower()
+            if lowerCaseId in conflictingMarkets:
+                conflictingMarket = conflictingMarkets[lowerCaseId]
+                baseId = conflictingMarket['base']
+                quoteId = conflictingMarket['quote']
+                if isPerp:
+                    settleId = conflictingMarket['quote']
+            else:
+                quoteCurrencies = self.handle_option('fetchMarketsFromAPI', 'quoteCurrencies', [])
+                for i in range(0, len(quoteCurrencies)):
+                    quoteCurrency = quoteCurrencies[i]
+                    if marketIdWithoutPerp.endswith(quoteCurrency):
+                        quoteLength = self.parse_to_int(-1 * len(quoteCurrency))
+                        baseId = marketIdWithoutPerp[0:quoteLength]
+                        quoteId = quoteCurrency
+                        if isPerp:
+                            settleId = quoteCurrency  # always same
+                        break
         base = self.safe_currency_code(baseId)
         quote = self.safe_currency_code(quoteId)
         settle = self.safe_currency_code(settleId)

ccxt/okx.py

@@ -8,6 +8,7 @@ from ccxt.abstract.okx import ImplicitAPI
 import hashlib
 from ccxt.base.types import Account, Balances, Conversion, Currencies, Currency, Greeks, Int, Leverage, MarginModification, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, Transaction, TransferEntry
 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 PermissionDenied
@@ -1129,13 +1130,13 @@ class okx(Exchange, ImplicitAPI):
             },
         })
 
-    def handle_market_type_and_params(self, methodName, market=None, params={}):
+    def handle_market_type_and_params(self, methodName: str, market: Market = None, params={}, defaultValue=None) -> Any:
         instType = self.safe_string(params, 'instType')
         params = self.omit(params, 'instType')
         type = self.safe_string(params, 'type')
         if (type is None) and (instType is not None):
             params['type'] = instType
-        return super(okx, self).handle_market_type_and_params(methodName, market, params)
+        return super(okx, self).handle_market_type_and_params(methodName, market, params, defaultValue)
 
     def convert_to_instrument_type(self, type):
         exchangeTypes = self.safe_dict(self.options, 'exchangeType', {})

ccxt/poloniexfutures.py

@@ -382,7 +382,10 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #
         marketId = self.safe_string(ticker, 'symbol')
         symbol = self.safe_symbol(marketId, market)
-        timestamp = self.safe_integer_product(ticker, 'ts', 0.000001)
+        timestampString = self.safe_string(ticker, 'ts')
+        # check timestamp bcz bug: https://app.travis-ci.com/github/ccxt/ccxt/builds/269959181#L4011
+        multiplier = 0.00001 if (len(timestampString) == 18) else 0.000001
+        timestamp = self.safe_integer_product(ticker, 'ts', multiplier)
         last = self.safe_string_2(ticker, 'price', 'lastPrice')
         percentage = Precise.string_mul(self.safe_string(ticker, 'priceChgPct'), '100')
         return self.safe_ticker({

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.95'
+__version__ = '4.2.97'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -9,10 +9,10 @@ import hashlib
 from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
-from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import NotSupported
+from ccxt.base.errors import InvalidNonce
 from ccxt.base.precise import Precise
 
 
@@ -400,8 +400,10 @@ class binance(ccxt.async_support.binance):
                             if nonce < orderbook['nonce']:
                                 client.resolve(orderbook, messageHash)
                         else:
-                            # todo: client.reject from handleOrderBookMessage properly
-                            raise ExchangeError(self.id + ' handleOrderBook received an out-of-order nonce')
+                            checksum = self.safe_bool(self.options, 'checksum', True)
+                            if checksum:
+                                # todo: client.reject from handleOrderBookMessage properly
+                                raise InvalidNonce(self.id + ' handleOrderBook received an out-of-order nonce')
                 else:
                     # future
                     # 4. Drop any event where u is < lastUpdateId in the snapshot
@@ -413,8 +415,10 @@ class binance(ccxt.async_support.binance):
                             if nonce <= orderbook['nonce']:
                                 client.resolve(orderbook, messageHash)
                         else:
-                            # todo: client.reject from handleOrderBookMessage properly
-                            raise ExchangeError(self.id + ' handleOrderBook received an out-of-order nonce')
+                            checksum = self.safe_bool(self.options, 'checksum', True)
+                            if checksum:
+                                # todo: client.reject from handleOrderBookMessage properly
+                                raise InvalidNonce(self.id + ' handleOrderBook received an out-of-order nonce')
             except Exception as e:
                 del self.orderbooks[symbol]
                 del client.subscriptions[messageHash]

ccxt/pro/coinbase.py

@@ -136,6 +136,11 @@ class coinbase(ccxt.async_support.coinbase):
         #                        "low_52_w": "15460",
         #                        "high_52_w": "48240",
         #                        "price_percent_chg_24_h": "-4.15775596190603"
+        # new 2024-04-12
+        #                        "best_bid":"21835.29",
+        #                        "best_bid_quantity": "0.02000000",
+        #                        "best_ask":"23011.18",
+        #                        "best_ask_quantity": "0.01500000"
         #                    }
         #                ]
         #            }
@@ -161,6 +166,11 @@ class coinbase(ccxt.async_support.coinbase):
         #                        "low_52_w": "0.04908",
         #                        "high_52_w": "0.1801",
         #                        "price_percent_chg_24_h": "0.50177456859626"
+        # new 2024-04-12
+        #                        "best_bid":"0.07989",
+        #                        "best_bid_quantity": "500.0",
+        #                        "best_ask":"0.08308",
+        #                        "best_ask_quantity": "300.0"
         #                    }
         #                ]
         #            }
@@ -209,6 +219,11 @@ class coinbase(ccxt.async_support.coinbase):
         #         "low_52_w": "0.04908",
         #         "high_52_w": "0.1801",
         #         "price_percent_chg_24_h": "0.50177456859626"
+        # new 2024-04-12
+        #         "best_bid":"0.07989",
+        #         "best_bid_quantity": "500.0",
+        #         "best_ask":"0.08308",
+        #         "best_ask_quantity": "300.0"
         #     }
         #
         marketId = self.safe_string(ticker, 'product_id')
@@ -221,10 +236,10 @@ class coinbase(ccxt.async_support.coinbase):
             'datetime': self.iso8601(timestamp),
             'high': self.safe_string(ticker, 'high_24_h'),
             'low': self.safe_string(ticker, 'low_24_h'),
-            'bid': None,
-            'bidVolume': None,
-            'ask': None,
-            'askVolume': None,
+            'bid': self.safe_string(ticker, 'best_bid'),
+            'bidVolume': self.safe_string(ticker, 'best_bid_quantity'),
+            'ask': self.safe_string(ticker, 'best_ask'),
+            'askVolume': self.safe_string(ticker, 'best_ask_quantity'),
             'vwap': None,
             'open': None,
             'close': last,

ccxt/pro/poloniexfutures.py

@@ -8,9 +8,9 @@ from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
 from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
-from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import BadRequest
+from ccxt.base.errors import InvalidNonce
 
 
 class poloniexfutures(ccxt.async_support.poloniexfutures):
@@ -817,7 +817,10 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         sequence = self.safe_integer(delta, 'sequence')
         nonce = self.safe_integer(orderbook, 'nonce')
         if nonce != sequence - 1:
-            raise ExchangeError(self.id + ' watchOrderBook received an out-of-order nonce')
+            checksum = self.safe_bool(self.options, 'checksum', True)
+            if checksum:
+                # todo: client.reject from handleOrderBookMessage properly
+                raise InvalidNonce(self.id + ' watchOrderBook received an out-of-order nonce')
         change = self.safe_string(delta, 'change')
         splitChange = change.split(',')
         price = self.safe_number(splitChange, 0)

ccxt/test/base/test_order_book.py

@@ -24,7 +24,9 @@ def test_order_book(exchange, skipped_properties, method, orderbook, symbol):
         'datetime': '2017-09-01T00:00:00',
         'nonce': 134234234,
     }
-    empty_allowed_for = ['symbol', 'nonce', 'datetime', 'timestamp']  # todo: make timestamp required
+    empty_allowed_for = ['nonce']
+    # turn into copy: https://discord.com/channels/690203284119617602/921046068555313202/1220626834887282728
+    orderbook = exchange.deep_extend({}, orderbook)
     test_shared_methods.assert_structure(exchange, skipped_properties, method, orderbook, format, empty_allowed_for)
     test_shared_methods.assert_timestamp_and_datetime(exchange, skipped_properties, method, orderbook)
     test_shared_methods.assert_symbol(exchange, skipped_properties, method, orderbook, 'symbol', symbol)
@@ -37,24 +39,28 @@ def test_order_book(exchange, skipped_properties, method, orderbook, symbol):
     bids_length = len(bids)
     for i in range(0, bids_length):
         current_bid_string = exchange.safe_string(bids[i], 0)
-        next_i = i + 1
-        if bids_length > next_i:
-            next_bid_string = exchange.safe_string(bids[next_i], 0)
-            has_correct_order = Precise.string_gt(current_bid_string, next_bid_string)
-            assert has_correct_order, 'current bid should be > than the next one: ' + current_bid_string + '>' + next_bid_string + log_text
-        test_shared_methods.assert_greater(exchange, skipped_properties, method, bids[i], 0, '0')
-        test_shared_methods.assert_greater(exchange, skipped_properties, method, bids[i], 1, '0')
+        if not ('compareToNextItem' in skipped_properties):
+            next_i = i + 1
+            if bids_length > next_i:
+                next_bid_string = exchange.safe_string(bids[next_i], 0)
+                assert Precise.string_gt(current_bid_string, next_bid_string), 'current bid should be > than the next one: ' + current_bid_string + '>' + next_bid_string + log_text
+        if not ('compareToZero' in skipped_properties):
+            # compare price & volume to zero
+            test_shared_methods.assert_greater(exchange, skipped_properties, method, bids[i], 0, '0')
+            test_shared_methods.assert_greater(exchange, skipped_properties, method, bids[i], 1, '0')
     asks = orderbook['asks']
     asks_length = len(asks)
     for i in range(0, asks_length):
         current_ask_string = exchange.safe_string(asks[i], 0)
-        next_i = i + 1
-        if asks_length > next_i:
-            next_ask_string = exchange.safe_string(asks[next_i], 0)
-            has_correct_order = Precise.string_lt(current_ask_string, next_ask_string)
-            assert has_correct_order, 'current ask should be < than the next one: ' + current_ask_string + '<' + next_ask_string + log_text
-        test_shared_methods.assert_greater(exchange, skipped_properties, method, asks[i], 0, '0')
-        test_shared_methods.assert_greater(exchange, skipped_properties, method, asks[i], 1, '0')
+        if not ('compareToNextItem' in skipped_properties):
+            next_i = i + 1
+            if asks_length > next_i:
+                next_ask_string = exchange.safe_string(asks[next_i], 0)
+                assert Precise.string_lt(current_ask_string, next_ask_string), 'current ask should be < than the next one: ' + current_ask_string + '<' + next_ask_string + log_text
+        if not ('compareToZero' in skipped_properties):
+            # compare price & volume to zero
+            test_shared_methods.assert_greater(exchange, skipped_properties, method, asks[i], 0, '0')
+            test_shared_methods.assert_greater(exchange, skipped_properties, method, asks[i], 1, '0')
     if not ('spread' in skipped_properties):
         if bids_length and asks_length:
             first_bid = exchange.safe_string(bids[0], 0)

ccxt/test/test_async.py

@@ -422,9 +422,13 @@ class testMainClass(baseMainTestClass):
         return result
 
     async def test_method(self, method_name, exchange, args, is_public):
+        # todo: temporary skip for c#
+        if 'OrderBook' in method_name and self.ext == 'cs':
+            exchange.options['checksum'] = False
         # todo: temporary skip for php
         if 'OrderBook' in method_name and self.ext == 'php':
             return
+        skipped_properties_for_method = self.get_skips(exchange, method_name)
         is_load_markets = (method_name == 'loadMarkets')
         is_fetch_currencies = (method_name == 'fetchCurrencies')
         is_proxy_test = (method_name == self.proxy_test_file_name)
@@ -437,7 +441,7 @@ class testMainClass(baseMainTestClass):
             skip_message = '[INFO] IGNORED_TEST'
         elif not is_load_markets and not supported_by_exchange and not is_proxy_test:
             skip_message = '[INFO] UNSUPPORTED_TEST'  # keep it aligned with the longest message
-        elif (method_name in self.skipped_methods) and (isinstance(self.skipped_methods[method_name], str)):
+        elif isinstance(skipped_properties_for_method, str):
             skip_message = '[INFO] SKIPPED_TEST'
         elif not (method_name in self.test_files):
             skip_message = '[INFO] UNIMPLEMENTED_TEST'
@@ -451,15 +455,24 @@ class testMainClass(baseMainTestClass):
         if self.info:
             args_stringified = '(' + ','.join(args) + ')'
             dump(self.add_padding('[INFO] TESTING', 25), self.exchange_hint(exchange), method_name, args_stringified)
-        await call_method(self.test_files, method_name, exchange, self.get_skips(exchange, method_name), args)
+        await call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
         # if it was passed successfully, add to the list of successfull tests
         if is_public:
             self.checked_public_tests[method_name] = True
         return
 
     def get_skips(self, exchange, method_name):
-        # get "method-specific" skips
-        skips_for_method = exchange.safe_value(self.skipped_methods, method_name, {})
+        final_skips = {}
+        # check the exact method (i.e. `fetchTrades`) and language-specific (i.e. `fetchTrades.php`)
+        method_names = [method_name, method_name + '.' + self.ext]
+        for i in range(0, len(method_names)):
+            m_name = method_names[i]
+            if m_name in self.skipped_methods:
+                # if whole method is skipped, by assigning a string to it, i.e. "fetchOrders":"blabla"
+                if isinstance(self.skipped_methods[m_name], str):
+                    return self.skipped_methods[m_name]
+                else:
+                    final_skips = exchange.deep_extend(final_skips, self.skipped_methods[m_name])
         # get "object-specific" skips
         object_skips = {
             'orderBook': ['fetchOrderBook', 'fetchOrderBooks', 'fetchL2OrderBook', 'watchOrderBook', 'watchOrderBookForSymbols'],
@@ -475,9 +488,19 @@ class testMainClass(baseMainTestClass):
             object_name = object_names[i]
             object_methods = object_skips[object_name]
             if exchange.in_array(method_name, object_methods):
+                # if whole object is skipped, by assigning a string to it, i.e. "orderBook":"blabla"
+                if (object_name in self.skipped_methods) and (isinstance(self.skipped_methods[object_name], str)):
+                    return self.skipped_methods[object_name]
                 extra_skips = exchange.safe_dict(self.skipped_methods, object_name, {})
-                return exchange.deep_extend(skips_for_method, extra_skips)
-        return skips_for_method
+                final_skips = exchange.deep_extend(final_skips, extra_skips)
+        # extend related skips
+        # - if 'timestamp' is skipped, we should do so for 'datetime' too
+        # - if 'bid' is skipped, skip 'ask' too
+        if ('timestamp' in final_skips) and not ('datetime' in final_skips):
+            final_skips['datetime'] = final_skips['timestamp']
+        if ('bid' in final_skips) and not ('ask' in final_skips):
+            final_skips['ask'] = final_skips['bid']
+        return final_skips
 
     async def test_safe(self, method_name, exchange, args=[], is_public=False):
         # `testSafe` method does not throw an exception, instead mutes it. The reason we
@@ -569,11 +592,14 @@ class testMainClass(baseMainTestClass):
         if self.ws_tests:
             tests = {
                 'watchOHLCV': [symbol],
+                'watchOHLCVForSymbols': [symbol],
                 'watchTicker': [symbol],
                 'watchTickers': [symbol],
                 'watchBidsAsks': [symbol],
                 'watchOrderBook': [symbol],
+                'watchOrderBookForSymbols': [[symbol]],
                 'watchTrades': [symbol],
+                'watchTradesForSymbols': [[symbol]],
             }
         market = exchange.market(symbol)
         is_spot = market['spot']

ccxt/test/test_sync.py

@@ -421,9 +421,13 @@ class testMainClass(baseMainTestClass):
         return result
 
     def test_method(self, method_name, exchange, args, is_public):
+        # todo: temporary skip for c#
+        if 'OrderBook' in method_name and self.ext == 'cs':
+            exchange.options['checksum'] = False
         # todo: temporary skip for php
         if 'OrderBook' in method_name and self.ext == 'php':
             return
+        skipped_properties_for_method = self.get_skips(exchange, method_name)
         is_load_markets = (method_name == 'loadMarkets')
         is_fetch_currencies = (method_name == 'fetchCurrencies')
         is_proxy_test = (method_name == self.proxy_test_file_name)
@@ -436,7 +440,7 @@ class testMainClass(baseMainTestClass):
             skip_message = '[INFO] IGNORED_TEST'
         elif not is_load_markets and not supported_by_exchange and not is_proxy_test:
             skip_message = '[INFO] UNSUPPORTED_TEST'  # keep it aligned with the longest message
-        elif (method_name in self.skipped_methods) and (isinstance(self.skipped_methods[method_name], str)):
+        elif isinstance(skipped_properties_for_method, str):
             skip_message = '[INFO] SKIPPED_TEST'
         elif not (method_name in self.test_files):
             skip_message = '[INFO] UNIMPLEMENTED_TEST'
@@ -450,15 +454,24 @@ class testMainClass(baseMainTestClass):
         if self.info:
             args_stringified = '(' + ','.join(args) + ')'
             dump(self.add_padding('[INFO] TESTING', 25), self.exchange_hint(exchange), method_name, args_stringified)
-        call_method(self.test_files, method_name, exchange, self.get_skips(exchange, method_name), args)
+        call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
         # if it was passed successfully, add to the list of successfull tests
         if is_public:
             self.checked_public_tests[method_name] = True
         return
 
     def get_skips(self, exchange, method_name):
-        # get "method-specific" skips
-        skips_for_method = exchange.safe_value(self.skipped_methods, method_name, {})
+        final_skips = {}
+        # check the exact method (i.e. `fetchTrades`) and language-specific (i.e. `fetchTrades.php`)
+        method_names = [method_name, method_name + '.' + self.ext]
+        for i in range(0, len(method_names)):
+            m_name = method_names[i]
+            if m_name in self.skipped_methods:
+                # if whole method is skipped, by assigning a string to it, i.e. "fetchOrders":"blabla"
+                if isinstance(self.skipped_methods[m_name], str):
+                    return self.skipped_methods[m_name]
+                else:
+                    final_skips = exchange.deep_extend(final_skips, self.skipped_methods[m_name])
         # get "object-specific" skips
         object_skips = {
             'orderBook': ['fetchOrderBook', 'fetchOrderBooks', 'fetchL2OrderBook', 'watchOrderBook', 'watchOrderBookForSymbols'],
@@ -474,9 +487,19 @@ class testMainClass(baseMainTestClass):
             object_name = object_names[i]
             object_methods = object_skips[object_name]
             if exchange.in_array(method_name, object_methods):
+                # if whole object is skipped, by assigning a string to it, i.e. "orderBook":"blabla"
+                if (object_name in self.skipped_methods) and (isinstance(self.skipped_methods[object_name], str)):
+                    return self.skipped_methods[object_name]
                 extra_skips = exchange.safe_dict(self.skipped_methods, object_name, {})
-                return exchange.deep_extend(skips_for_method, extra_skips)
-        return skips_for_method
+                final_skips = exchange.deep_extend(final_skips, extra_skips)
+        # extend related skips
+        # - if 'timestamp' is skipped, we should do so for 'datetime' too
+        # - if 'bid' is skipped, skip 'ask' too
+        if ('timestamp' in final_skips) and not ('datetime' in final_skips):
+            final_skips['datetime'] = final_skips['timestamp']
+        if ('bid' in final_skips) and not ('ask' in final_skips):
+            final_skips['ask'] = final_skips['bid']
+        return final_skips
 
     def test_safe(self, method_name, exchange, args=[], is_public=False):
         # `testSafe` method does not throw an exception, instead mutes it. The reason we
@@ -568,11 +591,14 @@ class testMainClass(baseMainTestClass):
         if self.ws_tests:
             tests = {
                 'watchOHLCV': [symbol],
+                'watchOHLCVForSymbols': [symbol],
                 'watchTicker': [symbol],
                 'watchTickers': [symbol],
                 'watchBidsAsks': [symbol],
                 'watchOrderBook': [symbol],
+                'watchOrderBookForSymbols': [[symbol]],
                 'watchTrades': [symbol],
+                'watchTradesForSymbols': [[symbol]],
             }
         market = exchange.market(symbol)
         is_spot = market['spot']

{ccxt-4.2.95.dist-info → ccxt-4.2.97.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.2.95
+Version: 4.2.97
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -261,13 +261,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.2.95/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.2.95/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.2.97/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.2.97/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.2.95/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.2.97/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: