ccxt 4.2.35__py2.py3-none-any.whl → 4.2.37__py2.py3-none-any.whl

ccxt/bitmex.py

@@ -292,6 +292,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_currencies(self, params={}):
         """
         fetches all available currencies on an exchange
+        :see: https://www.bitmex.com/api/explorer/#not /Wallet/Wallet_getAssetsConfig
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
@@ -752,6 +753,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_balance(self, params={}) -> Balances:
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://www.bitmex.com/api/explorer/#not /User/User_getMargin
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
@@ -812,6 +814,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://www.bitmex.com/api/explorer/#not /OrderBook/OrderBook_getL2
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -850,6 +853,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
+        :see: https://www.bitmex.com/api/explorer/#not /Order/Order_getOrders
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -907,6 +911,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetch all unfilled currently open orders
+        :see: https://www.bitmex.com/api/explorer/#not /Order/Order_getOrders
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of  open orders structures to retrieve
@@ -923,6 +928,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple closed orders made by the user
+        :see: https://www.bitmex.com/api/explorer/#not /Order/Order_getOrders
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -935,8 +941,8 @@ class bitmex(Exchange, ImplicitAPI):
 
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        :see: https://www.bitmex.com/api/explorer/#not /Execution/Execution_getTradeHistory
         fetch all trades made by the user
+        :see: https://www.bitmex.com/api/explorer/#not /Execution/Execution_getTradeHistory
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trades structures to retrieve
@@ -1132,6 +1138,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_ledger(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch the history of changes, actions done by the user or operations that altered balance of the user
+        :see: https://www.bitmex.com/api/explorer/#not /User/User_getWalletHistory
         :param str code: unified currency code, default is None
         :param int [since]: timestamp in ms of the earliest ledger entry, default is None
         :param int [limit]: max number of ledger entrys to return, default is None
@@ -1179,6 +1186,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_deposits_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch history of deposits and withdrawals
+        :see: https://www.bitmex.com/api/explorer/#not /User/User_getWalletHistory
         :param str [code]: unified currency code for the currency of the deposit/withdrawals, default is None
         :param int [since]: timestamp in ms of the earliest deposit/withdrawal, default is None
         :param int [limit]: max number of deposit/withdrawals to return, default is None
@@ -1290,6 +1298,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://www.bitmex.com/api/explorer/#not /Instrument/Instrument_get
         :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>`
@@ -1308,6 +1317,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+        :see: https://www.bitmex.com/api/explorer/#not /Instrument/Instrument_getActiveAndIndices
         :param str[]|None 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
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -1386,8 +1396,8 @@ class bitmex(Exchange, ImplicitAPI):
 
     def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://www.bitmex.com/api/explorer/#not /Trade/Trade_getBucketed
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://www.bitmex.com/api/explorer/#not /Trade/Trade_getBucketed
         :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
@@ -1683,8 +1693,8 @@ class bitmex(Exchange, ImplicitAPI):
 
     def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://www.bitmex.com/api/explorer/#not /Trade/Trade_get
         get the list of most recent trades for a particular symbol
+        :see: https://www.bitmex.com/api/explorer/#not /Trade/Trade_get
         :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
@@ -1866,6 +1876,7 @@ class bitmex(Exchange, ImplicitAPI):
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
+        :see: https://www.bitmex.com/api/explorer/#not /Order/Order_cancel
         :param str id: order id
         :param str symbol: not used by bitmex cancelOrder()
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1891,6 +1902,7 @@ class bitmex(Exchange, ImplicitAPI):
     def cancel_orders(self, ids, symbol: Str = None, params={}):
         """
         cancel multiple orders
+        :see: https://www.bitmex.com/api/explorer/#not /Order/Order_cancel
         :param str[] ids: order ids
         :param str symbol: not used by bitmex cancelOrders()
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1912,6 +1924,7 @@ class bitmex(Exchange, ImplicitAPI):
     def cancel_all_orders(self, symbol: Str = None, params={}):
         """
         cancel all open orders
+        :see: https://www.bitmex.com/api/explorer/#not /Order/Order_cancelAll
         :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1967,6 +1980,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_positions(self, symbols: Strings = None, params={}):
         """
         fetch all open positions
+        :see: https://www.bitmex.com/api/explorer/#not /Position/Position_get
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/#/?id=position-structure>`
@@ -2220,6 +2234,7 @@ class bitmex(Exchange, ImplicitAPI):
     def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         make a withdrawal
+        :see: https://www.bitmex.com/api/explorer/#not /User/User_requestWithdrawal
         :param str code: unified currency code
         :param float amount: the amount to withdraw
         :param str address: the address to withdraw to
@@ -2265,6 +2280,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_funding_rates(self, symbols: Strings = None, params={}):
         """
         fetch the funding rate for multiple markets
+        :see: https://www.bitmex.com/api/explorer/#not /Instrument/Instrument_getActiveAndIndices
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `funding rates structures <https://docs.ccxt.com/#/?id=funding-rates-structure>`, indexe by market symbols
@@ -2312,6 +2328,7 @@ class bitmex(Exchange, ImplicitAPI):
     def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         Fetches the history of funding rates
+        :see: https://www.bitmex.com/api/explorer/#not /Funding/Funding_get
         :param str symbol: unified symbol of the market to fetch the funding rate history for
         :param int [since]: timestamp in ms of the earliest funding rate to fetch
         :param int [limit]: the maximum amount of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>` to fetch
@@ -2386,6 +2403,7 @@ class bitmex(Exchange, ImplicitAPI):
     def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
         """
         set the level of leverage for a market
+        :see: https://www.bitmex.com/api/explorer/#not /Position/Position_updateLeverage
         :param float leverage: the rate of leverage
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2408,6 +2426,7 @@ class bitmex(Exchange, ImplicitAPI):
     def set_margin_mode(self, marginMode, symbol: Str = None, params={}):
         """
         set margin mode to 'cross' or 'isolated'
+        :see: https://www.bitmex.com/api/explorer/#not /Position/Position_isolateMargin
         :param str marginMode: 'cross' or 'isolated'
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint

ccxt/bybit.py

@@ -3525,9 +3525,19 @@ class bybit(Exchange, ImplicitAPI):
             if isStopLoss:
                 slTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
                 request['stopLoss'] = self.price_to_precision(symbol, slTriggerPrice)
+                slLimitPrice = self.safe_value(stopLoss, 'price')
+                if slLimitPrice is not None:
+                    request['tpslMode'] = 'Partial'
+                    request['slOrderType'] = 'Limit'
+                    request['slLimitPrice'] = self.price_to_precision(symbol, slLimitPrice)
             if isTakeProfit:
                 tpTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
                 request['takeProfit'] = self.price_to_precision(symbol, tpTriggerPrice)
+                tpLimitPrice = self.safe_value(takeProfit, 'price')
+                if tpLimitPrice is not None:
+                    request['tpslMode'] = 'Partial'
+                    request['tpOrderType'] = 'Limit'
+                    request['tpLimitPrice'] = self.price_to_precision(symbol, tpLimitPrice)
         if market['spot']:
             # only works for spot market
             if triggerPrice is not None:
@@ -5621,9 +5631,6 @@ class bybit(Exchange, ImplicitAPI):
         timestamp = self.parse8601(self.safe_string(position, 'updated_at'))
         if timestamp is None:
             timestamp = self.safe_integer_n(position, ['updatedTime', 'updatedAt'])
-        # default to cross of USDC margined positions
-        tradeMode = self.safe_integer(position, 'tradeMode', 0)
-        marginMode = 'isolated' if tradeMode else 'cross'
         collateralString = self.safe_string(position, 'positionBalance')
         entryPrice = self.omit_zero(self.safe_string_2(position, 'entryPrice', 'avgPrice'))
         liquidationPrice = self.omit_zero(self.safe_string(position, 'liqPrice'))
@@ -5680,7 +5687,7 @@ class bybit(Exchange, ImplicitAPI):
             'markPrice': self.safe_number(position, 'markPrice'),
             'lastPrice': None,
             'collateral': self.parse_number(collateralString),
-            'marginMode': marginMode,
+            'marginMode': None,
             'side': side,
             'percentage': None,
             'stopLossPrice': self.safe_number_2(position, 'stop_loss', 'stopLoss'),

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.35'
+__version__ = '4.2.37'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -56,8 +56,8 @@ class binance(ccxt.async_support.binance):
                 },
                 'api': {
                     'ws': {
-                        'spot': 'wss://stream.binance.com/ws',
-                        'margin': 'wss://stream.binance.com/ws',
+                        'spot': 'wss://stream.binance.com:9443/ws',
+                        'margin': 'wss://stream.binance.com:9443/ws',
                         'future': 'wss://fstream.binance.com/ws',
                         'delivery': 'wss://dstream.binance.com/ws',
                         'ws': 'wss://ws-api.binance.com:443/ws-api/v3',

ccxt/pro/gemini.py

@@ -10,6 +10,7 @@ from ccxt.base.types import Int, Order, OrderBook, Str, 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 NotSupported
 
 
 class gemini(ccxt.async_support.gemini):
@@ -22,9 +23,11 @@ class gemini(ccxt.async_support.gemini):
                 'watchTicker': False,
                 'watchTickers': False,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
                 'watchMyTrades': False,
                 'watchOrders': True,
                 'watchOrderBook': True,
+                'watchOrderBookForSymbols': True,
                 'watchOHLCV': True,
             },
             'hostname': 'api.gemini.com',
@@ -70,7 +73,26 @@ class gemini(ccxt.async_support.gemini):
             limit = trades.getLimit(market['symbol'], limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
-    def parse_ws_trade(self, trade, market=None):
+    async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        :see: https://docs.gemini.com/websocket-api/#multi-market-data
+        get the list of most recent trades for a list of symbols
+        :param str[] symbols: 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>`
+        """
+        trades = await self.helper_for_watch_multiple_construct('trades', symbols, params)
+        if self.newUpdates:
+            first = self.safe_list(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
+    def parse_ws_trade(self, trade, market=None) -> Trade:
+        #
+        # regular v2 trade
         #
         #     {
         #         "type": "trade",
@@ -82,11 +104,28 @@ class gemini(ccxt.async_support.gemini):
         #         "side": "buy"
         #     }
         #
+        # multi data trade
+        #
+        #    {
+        #        "type": "trade",
+        #        "symbol": "ETHUSD",
+        #        "tid": "1683002242170204",  # self is not TS, but somewhat ID
+        #        "price": "2299.24",
+        #        "amount": "0.002662",
+        #        "makerSide": "bid"
+        #    }
+        #
         timestamp = self.safe_integer(trade, 'timestamp')
-        id = self.safe_string(trade, 'event_id')
+        id = self.safe_string_2(trade, 'event_id', 'tid')
         priceString = self.safe_string(trade, 'price')
-        amountString = self.safe_string(trade, 'quantity')
+        amountString = self.safe_string_2(trade, 'quantity', 'amount')
         side = self.safe_string_lower(trade, 'side')
+        if side is None:
+            marketSide = self.safe_string_lower(trade, 'makerSide')
+            if marketSide == 'bid':
+                side = 'sell'
+            elif marketSide == 'ask':
+                side = 'buy'
         marketId = self.safe_string_lower(trade, 'symbol')
         symbol = self.safe_symbol(marketId, market)
         return self.safe_trade({
@@ -182,6 +221,30 @@ class gemini(ccxt.async_support.gemini):
             messageHash = 'trades:' + symbol
             client.resolve(stored, messageHash)
 
+    def handle_trades_for_multidata(self, client: Client, trades, timestamp: Int):
+        if trades is not None:
+            tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            storesForSymbols = {}
+            for i in range(0, len(trades)):
+                marketId = trades[i]['symbol']
+                market = self.safe_market(marketId.lower())
+                symbol = market['symbol']
+                trade = self.parse_ws_trade(trades[i], market)
+                trade['timestamp'] = timestamp
+                trade['datetime'] = self.iso8601(timestamp)
+                stored = self.safe_value(self.trades, symbol)
+                if stored is None:
+                    stored = ArrayCache(tradesLimit)
+                    self.trades[symbol] = stored
+                stored.append(trade)
+                storesForSymbols[symbol] = stored
+            symbols = list(storesForSymbols.keys())
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                stored = storesForSymbols[symbol]
+                messageHash = 'trades:' + symbol
+                client.resolve(stored, messageHash)
+
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
@@ -317,6 +380,83 @@ class gemini(ccxt.async_support.gemini):
         self.orderbooks[symbol] = orderbook
         client.resolve(orderbook, messageHash)
 
+    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
+        :see: https://docs.gemini.com/websocket-api/#multi-market-data
+        :param str[] symbols: unified array of symbols
+        :param int [limit]: the maximum amount of order book entries to return
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        orderbook = await self.helper_for_watch_multiple_construct('orderbook', symbols, params)
+        return orderbook.limit()
+
+    async def helper_for_watch_multiple_construct(self, itemHashName: str, symbols: List[str], params={}):
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False, True, True)
+        firstMarket = self.market(symbols[0])
+        if not firstMarket['spot'] and not firstMarket['linear']:
+            raise NotSupported(self.id + ' watchMultiple supports only spot or linear-swap symbols')
+        messageHashes = []
+        marketIds = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHash = itemHashName + ':' + symbol
+            messageHashes.append(messageHash)
+            market = self.market(symbol)
+            marketIds.append(market['id'])
+        queryStr = ','.join(marketIds)
+        url = self.urls['api']['ws'] + '/v1/multimarketdata?symbols=' + queryStr + '&heartbeat=true&'
+        if itemHashName == 'orderbook':
+            url += 'trades=false&bids=true&offers=true'
+        elif itemHashName == 'trades':
+            url += 'trades=true&bids=false&offers=false'
+        return await self.watch_multiple(url, messageHashes, None)
+
+    def handle_order_book_for_multidata(self, client: Client, rawOrderBookChanges, timestamp: Int, nonce: Int):
+        #
+        # rawOrderBookChanges
+        #
+        # [
+        #   {
+        #     delta: "4105123935484.817624",
+        #     price: "0.000000001",
+        #     reason: "initial",  # initial|cancel|place
+        #     remaining: "4105123935484.817624",
+        #     side: "bid",  # bid|ask
+        #     symbol: "SHIBUSD",
+        #     type: "change",  # seems always change
+        #   },
+        #   ...
+        #
+        marketId = rawOrderBookChanges[0]['symbol']
+        market = self.safe_market(marketId.lower())
+        symbol = market['symbol']
+        messageHash = 'orderbook:' + symbol
+        orderbook = self.safe_dict(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book()
+        bids = orderbook['bids']
+        asks = orderbook['asks']
+        for i in range(0, len(rawOrderBookChanges)):
+            entry = rawOrderBookChanges[i]
+            price = self.safe_number(entry, 'price')
+            size = self.safe_number(entry, 'remaining')
+            rawSide = self.safe_string(entry, 'side')
+            if rawSide == 'bid':
+                bids.store(price, size)
+            else:
+                asks.store(price, size)
+        orderbook['bids'] = bids
+        orderbook['asks'] = asks
+        orderbook['symbol'] = symbol
+        orderbook['nonce'] = nonce
+        orderbook['timestamp'] = timestamp
+        orderbook['datetime'] = self.iso8601(timestamp)
+        self.orderbooks[symbol] = orderbook
+        client.resolve(orderbook, messageHash)
+
     def handle_l2_updates(self, client: Client, message):
         #
         #     {
@@ -393,6 +533,7 @@ class gemini(ccxt.async_support.gemini):
         #         "socket_sequence": 7
         #     }
         #
+        client.lastPong = self.milliseconds()
         return message
 
     def handle_subscription(self, client: Client, message):
@@ -586,6 +727,27 @@ class gemini(ccxt.async_support.gemini):
         method = self.safe_value(methods, type)
         if method is not None:
             method(client, message)
+        # handle multimarketdata
+        if type == 'update':
+            ts = self.safe_integer(message, 'timestampms', self.milliseconds())
+            eventId = self.safe_integer(message, 'eventId')
+            events = self.safe_list(message, 'events')
+            orderBookItems = []
+            collectedEventsOfTrades = []
+            for i in range(0, len(events)):
+                event = events[i]
+                eventType = self.safe_string(event, 'type')
+                isOrderBook = (eventType == 'change') and ('side' in event) and self.in_array(event['side'], ['ask', 'bid'])
+                if isOrderBook:
+                    orderBookItems.append(event)
+                elif eventType == 'trade':
+                    collectedEventsOfTrades.append(events[i])
+            lengthOb = len(orderBookItems)
+            if lengthOb > 0:
+                self.handle_order_book_for_multidata(client, orderBookItems, ts, eventId)
+            lengthTrades = len(collectedEventsOfTrades)
+            if lengthTrades > 0:
+                self.handle_trades_for_multidata(client, collectedEventsOfTrades, ts)
 
     async def authenticate(self, params={}):
         url = self.safe_string(params, 'url')

ccxt/test/test_async.py

@@ -816,10 +816,10 @@ class testMainClass(baseMainTestClass):
         #  --- Init of static tests functions------------------------------------------
         #  -----------------------------------------------------------------------------
         calculated_string = json_stringify(calculated_output)
-        output_string = json_stringify(stored_output)
-        error_message = message + ' expected ' + output_string + ' received: ' + calculated_string
+        stored_string = json_stringify(stored_output)
+        error_message = message + ' computed ' + stored_string + ' stored: ' + calculated_string
         if key is not None:
-            error_message = ' | ' + key + ' | ' + 'computed value: ' + output_string + ' stored value: ' + calculated_string
+            error_message = ' | ' + key + ' | ' + 'computed value: ' + stored_string + ' stored value: ' + calculated_string
         assert cond, error_message
 
     def load_markets_from_file(self, id):
@@ -1141,7 +1141,9 @@ class testMainClass(baseMainTestClass):
         await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
-    def get_number_of_tests_from_exchange(self, exchange, exchange_data):
+    def get_number_of_tests_from_exchange(self, exchange, exchange_data, test_name=None):
+        if test_name is not None:
+            return 1
         sum = 0
         methods = exchange_data['methods']
         methods_names = list(methods.keys())
@@ -1171,7 +1173,7 @@ class testMainClass(baseMainTestClass):
         for i in range(0, len(exchanges)):
             exchange_name = exchanges[i]
             exchange_data = static_data[exchange_name]
-            number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data)
+            number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data, test_name)
             sum = exchange.sum(sum, number_of_tests)
             if type == 'request':
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
@@ -1444,5 +1446,5 @@ class testMainClass(baseMainTestClass):
 
 
 if __name__ == '__main__':
-    symbol = argv.symbol if argv.symbol and '/' in argv.symbol else None
+    symbol = argv.symbol if argv.symbol else None
     asyncio.run(testMainClass().init(argv.exchange, symbol))

ccxt/test/test_sync.py

@@ -815,10 +815,10 @@ class testMainClass(baseMainTestClass):
         #  --- Init of static tests functions------------------------------------------
         #  -----------------------------------------------------------------------------
         calculated_string = json_stringify(calculated_output)
-        output_string = json_stringify(stored_output)
-        error_message = message + ' expected ' + output_string + ' received: ' + calculated_string
+        stored_string = json_stringify(stored_output)
+        error_message = message + ' computed ' + stored_string + ' stored: ' + calculated_string
         if key is not None:
-            error_message = ' | ' + key + ' | ' + 'computed value: ' + output_string + ' stored value: ' + calculated_string
+            error_message = ' | ' + key + ' | ' + 'computed value: ' + stored_string + ' stored value: ' + calculated_string
         assert cond, error_message
 
     def load_markets_from_file(self, id):
@@ -1140,7 +1140,9 @@ class testMainClass(baseMainTestClass):
         close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
-    def get_number_of_tests_from_exchange(self, exchange, exchange_data):
+    def get_number_of_tests_from_exchange(self, exchange, exchange_data, test_name=None):
+        if test_name is not None:
+            return 1
         sum = 0
         methods = exchange_data['methods']
         methods_names = list(methods.keys())
@@ -1170,7 +1172,7 @@ class testMainClass(baseMainTestClass):
         for i in range(0, len(exchanges)):
             exchange_name = exchanges[i]
             exchange_data = static_data[exchange_name]
-            number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data)
+            number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data, test_name)
             sum = exchange.sum(sum, number_of_tests)
             if type == 'request':
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
@@ -1443,5 +1445,5 @@ class testMainClass(baseMainTestClass):
 
 
 if __name__ == '__main__':
-    symbol = argv.symbol if argv.symbol and '/' in argv.symbol else None
+    symbol = argv.symbol if argv.symbol else None
     (testMainClass().init(argv.exchange, symbol))