ccxt 4.4.7__py2.py3-none-any.whl → 4.4.9__py2.py3-none-any.whl

ccxt/pro/hitbtc.py

@@ -22,6 +22,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'ws': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': False,
                 'watchOrderBook': True,
@@ -56,8 +57,11 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'watchTickers': {
                     'method': 'ticker/{speed}',  # 'ticker/{speed}','ticker/price/{speed}', 'ticker/{speed}/batch', or 'ticker/{speed}/price/batch''
                 },
+                'watchBidsAsks': {
+                    'method': 'orderbook/top/{speed}',  # 'orderbook/top/{speed}', 'orderbook/top/{speed}/batch'
+                },
                 'watchOrderBook': {
-                    'method': 'orderbook/full',  # 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch', 'orderbook/top/{speed}', or 'orderbook/top/{speed}/batch'
+                    'method': 'orderbook/full',  # 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch'
                 },
             },
             'timeframes': {
@@ -130,17 +134,22 @@ class hitbtc(ccxt.async_support.hitbtc):
         :param dict [params]: extra parameters specific to the hitbtc api
         """
         await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        isBatch = name.find('batch') >= 0
         url = self.urls['api']['ws']['public']
-        messageHash = messageHashPrefix
-        if symbols is not None:
-            messageHash = messageHash + '::' + ','.join(symbols)
+        messageHashes = []
+        if symbols is not None and not isBatch:
+            for i in range(0, len(symbols)):
+                messageHashes.append(messageHashPrefix + '::' + symbols[i])
+        else:
+            messageHashes.append(messageHashPrefix)
         subscribe: dict = {
             'method': 'subscribe',
             'id': self.nonce(),
             'ch': name,
         }
         request = self.extend(subscribe, params)
-        return await self.watch(url, messageHash, request, messageHash)
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
 
     async def subscribe_private(self, name: str, symbol: Str = None, params={}):
         """
@@ -192,7 +201,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         :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
-        :param str [params.method]: 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch', 'orderbook/top/{speed}', or 'orderbook/top/{speed}/batch'
+        :param str [params.method]: 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch'
         :param int [params.depth]: 5 , 10, or 20(default)
         :param int [params.speed]: 100(default), 500, or 1000
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
@@ -206,10 +215,6 @@ class hitbtc(ccxt.async_support.hitbtc):
             name = 'orderbook/D' + depth + '/' + speed + 'ms'
         elif name == 'orderbook/{depth}/{speed}/batch':
             name = 'orderbook/D' + depth + '/' + speed + 'ms/batch'
-        elif name == 'orderbook/top/{speed}':
-            name = 'orderbook/top/' + speed + 'ms'
-        elif name == 'orderbook/top/{speed}/batch':
-            name = 'orderbook/top/' + speed + 'ms/batch'
         market = self.market(symbol)
         request: dict = {
             'params': {
@@ -298,33 +303,22 @@ class hitbtc(ccxt.async_support.hitbtc):
         :param str [params.speed]: '1s'(default), or '3s'
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        options = self.safe_value(self.options, 'watchTicker')
-        defaultMethod = self.safe_string(options, 'method', 'ticker/{speed}')
-        method = self.safe_string_2(params, 'method', 'defaultMethod', defaultMethod)
-        speed = self.safe_string(params, 'speed', '1s')
-        name = self.implode_params(method, {'speed': speed})
-        params = self.omit(params, ['method', 'speed'])
-        market = self.market(symbol)
-        request: dict = {
-            'params': {
-                'symbols': [market['id']],
-            },
-        }
-        result = await self.subscribe_public(name, 'tickers', [symbol], self.deep_extend(request, params))
-        return self.safe_value(result, symbol)
+        ticker = await self.watch_tickers([symbol], params)
+        return self.safe_value(ticker, symbol)
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict params: extra parameters specific to the exchange API endpoint
-        :param str params['method']: 'ticker/{speed}'(default),'ticker/price/{speed}', 'ticker/{speed}/batch', or 'ticker/{speed}/price/batch''
+        :param str params['method']: 'ticker/{speed}' ,'ticker/price/{speed}', 'ticker/{speed}/batch'(default), or 'ticker/{speed}/price/batch''
         :param str params['speed']: '1s'(default), or '3s'
         :returns dict: a `ticker structure <https://docs.ccxt.com/en/latest/manual.html#ticker-structure>`
         """
         await self.load_markets()
+        symbols = self.market_symbols(symbols)
         options = self.safe_value(self.options, 'watchTicker')
-        defaultMethod = self.safe_string(options, 'method', 'ticker/{speed}')
+        defaultMethod = self.safe_string(options, 'method', 'ticker/{speed}/batch')
         method = self.safe_string_2(params, 'method', 'defaultMethod', defaultMethod)
         speed = self.safe_string(params, 'speed', '1s')
         name = self.implode_params(method, {'speed': speed})
@@ -341,10 +335,13 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': marketIds,
             },
         }
-        tickers = await self.subscribe_public(name, 'tickers', symbols, self.deep_extend(request, params))
+        newTickers = await self.subscribe_public(name, 'tickers', symbols, self.deep_extend(request, params))
         if self.newUpdates:
-            return tickers
-        return self.filter_by_array(self.tickers, 'symbol', symbols)
+            if not isinstance(newTickers, list):
+                tickers: dict = {}
+                tickers[newTickers['symbol']] = newTickers
+                return tickers
+        return self.filter_by_array(newTickers, 'symbol', symbols)
 
     def handle_ticker(self, client: Client, message):
         #
@@ -387,27 +384,18 @@ class hitbtc(ccxt.async_support.hitbtc):
         #
         data = self.safe_value(message, 'data', {})
         marketIds = list(data.keys())
-        newTickers: dict = {}
+        result = []
+        topic = 'tickers'
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
             market = self.safe_market(marketId)
             symbol = market['symbol']
             ticker = self.parse_ws_ticker(data[marketId], market)
             self.tickers[symbol] = ticker
-            newTickers[symbol] = ticker
-        client.resolve(newTickers, 'tickers')
-        messageHashes = self.find_message_hashes(client, 'tickers::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            tickersSymbols = list(tickers.keys())
-            numTickers = len(tickersSymbols)
-            if numTickers > 0:
-                client.resolve(tickers, messageHash)
-        return message
+            result.append(ticker)
+            messageHash = topic + '::' + symbol
+            client.resolve(ticker, messageHash)
+        client.resolve(result, topic)
 
     def parse_ws_ticker(self, ticker, market=None):
         #
@@ -464,6 +452,81 @@ class hitbtc(ccxt.async_support.hitbtc):
             'info': ticker,
         }, market)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches best bid & ask for symbols
+        :see: https://api.hitbtc.com/#subscribe-to-top-of-book
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.method]: 'orderbook/top/{speed}' or 'orderbook/top/{speed}/batch(default)'
+        :param str [params.speed]: '100ms'(default) or '500ms' or '1000ms'
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        options = self.safe_value(self.options, 'watchBidsAsks')
+        defaultMethod = self.safe_string(options, 'method', 'orderbook/top/{speed}/batch')
+        method = self.safe_string_2(params, 'method', 'defaultMethod', defaultMethod)
+        speed = self.safe_string(params, 'speed', '100ms')
+        name = self.implode_params(method, {'speed': speed})
+        params = self.omit(params, ['method', 'speed'])
+        marketIds = self.market_ids(symbols)
+        request: dict = {
+            'params': {
+                'symbols': marketIds,
+            },
+        }
+        newTickers = await self.subscribe_public(name, 'bidask', symbols, self.deep_extend(request, params))
+        if self.newUpdates:
+            if not isinstance(newTickers, list):
+                tickers: dict = {}
+                tickers[newTickers['symbol']] = newTickers
+                return tickers
+        return self.filter_by_array(newTickers, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #     {
+        #         "ch": "orderbook/top/100ms",  # or 'orderbook/top/100ms/batch'
+        #         "data": {
+        #             "BTCUSDT": {
+        #                 "t": 1727276919771,
+        #                 "a": "63931.45",
+        #                 "A": "0.02879",
+        #                 "b": "63926.97",
+        #                 "B": "0.00100"
+        #             }
+        #         }
+        #     }
+        #
+        data = self.safe_dict(message, 'data', {})
+        marketIds = list(data.keys())
+        result = []
+        topic = 'bidask'
+        for i in range(0, len(marketIds)):
+            marketId = marketIds[i]
+            market = self.safe_market(marketId)
+            symbol = market['symbol']
+            ticker = self.parse_ws_bid_ask(data[marketId], market)
+            self.bidsasks[symbol] = ticker
+            result.append(ticker)
+            messageHash = topic + '::' + symbol
+            client.resolve(ticker, messageHash)
+        client.resolve(result, topic)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        timestamp = self.safe_integer(ticker, 't')
+        return self.safe_ticker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string(ticker, 'a'),
+            'askVolume': self.safe_string(ticker, 'A'),
+            'bid': self.safe_string(ticker, 'b'),
+            'bidVolume': self.safe_string(ticker, 'B'),
+            'info': ticker,
+        }, market)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
@@ -1144,11 +1207,16 @@ class hitbtc(ccxt.async_support.hitbtc):
         if channel is not None:
             splitChannel = channel.split('/')
             channel = self.safe_string(splitChannel, 0)
+            if channel == 'orderbook':
+                channel2 = self.safe_string(splitChannel, 1)
+                if channel2 is not None and channel2 == 'top':
+                    channel = 'orderbook/top'
             methods: dict = {
                 'candles': self.handle_ohlcv,
                 'ticker': self.handle_ticker,
                 'trades': self.handle_trades,
                 'orderbook': self.handle_order_book,
+                'orderbook/top': self.handle_bid_ask,
                 'spot_order': self.handle_order,
                 'spot_orders': self.handle_order,
                 'margin_order': self.handle_order,

ccxt/pro/hollaex.py

@@ -62,6 +62,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :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
@@ -116,6 +117,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :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
@@ -167,6 +169,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made by the user
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :param str symbol: unified market symbol of the market trades were made in
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trade structures to retrieve
@@ -239,6 +242,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :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
@@ -350,6 +354,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """

ccxt/pro/okx.py

@@ -2055,10 +2055,21 @@ class okx(ccxt.async_support.okx):
         try:
             if errorCode and errorCode != '0':
                 feedback = self.id + ' ' + self.json(message)
-                self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
+                if errorCode != '1':
+                    self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
                 messageString = self.safe_value(message, 'msg')
                 if messageString is not None:
                     self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                else:
+                    data = self.safe_list(message, 'data', [])
+                    for i in range(0, len(data)):
+                        d = data[i]
+                        errorCode = self.safe_string(d, 'sCode')
+                        if errorCode is not None:
+                            self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
+                        messageString = self.safe_value(message, 'sMsg')
+                        if messageString is not None:
+                            self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
                 raise ExchangeError(feedback)
         except Exception as e:
             # if the message contains an id, it means it is a response to a request

ccxt/pro/p2b.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
-from ccxt.base.types import Int, OrderBook, Ticker, Trade
+from ccxt.base.types import Int, OrderBook, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -34,7 +34,7 @@ class p2b(ccxt.async_support.p2b):
                 'watchOrders': False,
                 # 'watchStatus': True,
                 'watchTicker': True,
-                'watchTickers': False,  # in the docs but does not return anything when subscribed to
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
             },
@@ -133,6 +133,36 @@ class p2b(ccxt.async_support.p2b):
         messageHash = name + '::' + market['symbol']
         return await self.subscribe(name + '.subscribe', messageHash, request, params)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#last-price
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#market-status
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :param str[] [symbols]: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param dict [params.method]: 'state'(default) or 'price'
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        watchTickerOptions = self.safe_dict(self.options, 'watchTicker')
+        name = self.safe_string(watchTickerOptions, 'name', 'state')  # or price
+        name, params = self.handle_option_and_params(params, 'method', 'name', name)
+        messageHashes = []
+        args = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            messageHashes.append(name + '::' + market['symbol'])
+            args.append(market['id'])
+        url = self.urls['api']['ws']
+        request: dict = {
+            'method': name + '.subscribe',
+            'params': args,
+            'id': self.milliseconds(),
+        }
+        await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
@@ -332,6 +362,7 @@ class p2b(ccxt.async_support.p2b):
         else:
             ticker = self.parse_ticker(tickerData, market)
         symbol = ticker['symbol']
+        self.tickers[symbol] = ticker
         messageHash = messageHashStart + '::' + symbol
         client.resolve(ticker, messageHash)
         return message

ccxt/pro/whitebit.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
@@ -26,6 +26,7 @@ class whitebit(ccxt.async_support.whitebit):
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': True,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': False,
             },
@@ -249,6 +250,33 @@ class whitebit(ccxt.async_support.whitebit):
         # every time we want to subscribe to another market we have to "re-subscribe" sending it all again
         return await self.watch_multiple_subscription(messageHash, method, symbol, False, params)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :see: https://docs.whitebit.com/public/websocket/#market-statistics
+        :param str[] [symbols]: 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()
+        symbols = self.market_symbols(symbols, None, False)
+        method = 'market_subscribe'
+        url = self.urls['api']['ws']
+        id = self.nonce()
+        messageHashes = []
+        args = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            messageHashes.append('ticker:' + market['symbol'])
+            args.append(market['id'])
+        request: dict = {
+            'id': id,
+            'method': method,
+            'params': args,
+        }
+        await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     def handle_ticker(self, client: Client, message):
         #
         #   {

{ccxt-4.4.7.dist-info → ccxt-4.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.7
+Version: 4.4.9
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -272,13 +272,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.4.7/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.7/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.9/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.9/dist/ccxt.browser.min.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.4.7/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.9/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object: