ccxt-ir 4.3.46.0.3__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/pro/upbit.py

@@ -5,20 +5,24 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Any, 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 NotSupported
 
 
 class upbit(ccxt.async_support.upbit):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(upbit, self).describe(), {
             'has': {
                 'ws': True,
                 'watchOrderBook': True,
                 'watchTicker': True,
+                'watchTickers': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
+                'watchOHLCV': True,
                 'watchOrders': True,
                 'watchMyTrades': True,
                 'watchBalance': True,
@@ -59,37 +63,127 @@ class upbit(ccxt.async_support.upbit):
         messageHash = channel + ':' + marketId
         return await self.watch(url, messageHash, request, messageHash)
 
+    async def watch_public_multiple(self, symbols: Strings, channel, params={}):
+        await self.load_markets()
+        if symbols is None:
+            symbols = self.symbols
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        url = self.implode_params(self.urls['api']['ws'], {
+            'hostname': self.hostname,
+        })
+        messageHashes = []
+        for i in range(0, len(marketIds)):
+            messageHashes.append(channel + ':' + marketIds[i])
+        request = [
+            {
+                'ticket': self.uuid(),
+            },
+            {
+                'type': channel,
+                'codes': marketIds,
+                # 'isOnlySnapshot': False,
+                # 'isOnlyRealtime': False,
+            },
+        ]
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://global-docs.upbit.com/reference/websocket-ticker
+
+        https://global-docs.upbit.com/reference/websocket-ticker
+
         :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>`
         """
         return await self.watch_public(symbol, 'ticker')
 
+    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
+
+        https://global-docs.upbit.com/reference/websocket-ticker
+
+        :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>`
+        """
+        newTickers = await self.watch_public_multiple(symbols, 'ticker')
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        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
-        :see: https://global-docs.upbit.com/reference/websocket-trade
+
+        https://global-docs.upbit.com/reference/websocket-trade
+
         :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.watch_trades_for_symbols([symbol], since, limit, 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 list of symbols
+
+        https://global-docs.upbit.com/reference/websocket-trade
+
+        :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>`
+        """
         await self.load_markets()
-        symbol = self.symbol(symbol)
-        trades = await self.watch_public(symbol, 'trade')
+        symbols = self.market_symbols(symbols, None, False, True, True)
+        channel = 'trade'
+        messageHashes = []
+        url = self.implode_params(self.urls['api']['ws'], {
+            'hostname': self.hostname,
+        })
+        if symbols is not None:
+            for i in range(0, len(symbols)):
+                market = self.market(symbols[i])
+                marketId = market['id']
+                symbol = market['symbol']
+                self.options[channel] = self.safe_value(self.options, channel, {})
+                self.options[channel][symbol] = True
+                messageHashes.append(channel + ':' + marketId)
+        optionSymbols = list(self.options[channel].keys())
+        marketIds = self.market_ids(optionSymbols)
+        request = [
+            {
+                'ticket': self.uuid(),
+            },
+            {
+                'type': channel,
+                'codes': marketIds,
+                # 'isOnlySnapshot': False,
+                # 'isOnlyRealtime': False,
+            },
+        ]
+        trades = await self.watch_multiple(url, messageHashes, request, messageHashes)
         if self.newUpdates:
-            limit = trades.getLimit(symbol, limit)
+            first = self.safe_value(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     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://global-docs.upbit.com/reference/websocket-orderbook
+
+        https://global-docs.upbit.com/reference/websocket-orderbook
+
         :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
@@ -98,6 +192,25 @@ class upbit(ccxt.async_support.upbit):
         orderbook = await self.watch_public(symbol, 'orderbook')
         return orderbook.limit()
 
+    async def watch_ohlcv(self, symbol: str, timeframe='1s', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        watches information an OHLCV with timestamp, openingPrice, highPrice, lowPrice, tradePrice, baseVolume in 1s.
+
+        https://docs.upbit.com/kr/reference/websocket-candle for Upbit KR
+        https://global-docs.upbit.com/reference/websocket-candle for Upbit Global
+
+        :param str symbol: unified market symbol of the market orders were made in
+        :param str timeframe: specifies the OHLCV candle interval to watch. As of now, Upbit only supports 1s candles.
+        :param int [since]: the earliest time in ms to fetch orders for
+        :param int [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns OHLCV[]: a list of `OHLCV structures <https://docs.ccxt.com/#/?id=ohlcv-structure>`
+        """
+        if timeframe != '1s':
+            raise NotSupported(self.id + ' watchOHLCV does not support' + timeframe + ' candle.')
+        timeFrameOHLCV = 'candle.' + timeframe
+        return await self.watch_public(symbol, timeFrameOHLCV)
+
     def handle_ticker(self, client: Client, message):
         # 2020-03-17T23:07:36.511Z "onMessage" <Buffer 7b 22 74 79 70 65 22 3a 22 74 69 63 6b 65 72 22 2c 22 63 6f 64 65 22 3a 22 42 54 43 2d 45 54 48 22 2c 22 6f 70 65 6e 69 6e 67 5f 70 72 69 63 65 22 3a ... >
         # {type: "ticker",
@@ -221,6 +334,26 @@ class upbit(ccxt.async_support.upbit):
         messageHash = 'trade:' + marketId
         client.resolve(stored, messageHash)
 
+    def handle_ohlcv(self, client: Client, message):
+        # {
+        #     type: 'candle.1s',
+        #     code: 'KRW-USDT',
+        #     candle_date_time_utc: '2025-04-22T09:50:34',
+        #     candle_date_time_kst: '2025-04-22T18:50:34',
+        #     opening_price: 1438,
+        #     high_price: 1438,
+        #     low_price: 1438,
+        #     trade_price: 1438,
+        #     candle_acc_trade_volume: 1145.8935,
+        #     candle_acc_trade_price: 1647794.853,
+        #     timestamp: 1745315434125,
+        #     stream_type: 'REALTIME'
+        #   }
+        marketId = self.safe_string(message, 'code')
+        messageHash = 'candle.1s:' + marketId
+        ohlcv = self.parse_ohlcv(message)
+        client.resolve(ohlcv, messageHash)
+
     async def authenticate(self, params={}):
         self.check_required_credentials()
         wsOptions: dict = self.safe_dict(self.options, 'ws', {})
@@ -270,7 +403,9 @@ class upbit(ccxt.async_support.upbit):
     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://global-docs.upbit.com/reference/websocket-myorder
+
+        https://global-docs.upbit.com/reference/websocket-myorder
+
         :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
@@ -288,12 +423,14 @@ class upbit(ccxt.async_support.upbit):
     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://global-docs.upbit.com/reference/websocket-myorder
+
+        https://global-docs.upbit.com/reference/websocket-myorder
+
         :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
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         await self.load_markets()
         channel = 'myOrder'
@@ -461,7 +598,9 @@ class upbit(ccxt.async_support.upbit):
 
     async def watch_balance(self, params={}) -> Balances:
         """
-        :see: https://global-docs.upbit.com/reference/websocket-myasset
+
+        https://global-docs.upbit.com/reference/websocket-myasset
+
         query for balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -513,6 +652,7 @@ class upbit(ccxt.async_support.upbit):
             'trade': self.handle_trades,
             'myOrder': self.handle_my_order,
             'myAsset': self.handle_balance,
+            'candle.1s': self.handle_ohlcv,
         }
         methodName = self.safe_string(message, 'type')
         method = self.safe_value(methods, methodName)

ccxt/pro/vertex.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide
-from ccxt.base.types import Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Trade
+from ccxt.base.types import Any, Bool, Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
@@ -16,7 +16,7 @@ from ccxt.base.precise import Precise
 
 class vertex(ccxt.async_support.vertex):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(vertex, self).describe(), {
             'has': {
                 'ws': True,
@@ -55,6 +55,11 @@ class vertex(ccxt.async_support.vertex):
                 },
                 'ws': {
                     'inflate': True,
+                    'options': {
+                        'headers': {
+                            'Sec-WebSocket-Extensions': 'permessage-deflate',  # requires permessage-deflate extension, maybe we can set self in client implementation when self.inflateis True
+                        },
+                    },
                 },
             },
             'streaming': {
@@ -893,7 +898,7 @@ class vertex(ccxt.async_support.vertex):
             cachedOrders.append(parsed)
             client.resolve(self.orders, marketId + '@' + topic)
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         # {
         #     result: null,

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 Any, Balances, Bool, 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
@@ -16,7 +16,7 @@ from ccxt.base.precise import Precise
 
 class whitebit(ccxt.async_support.whitebit):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(whitebit, self).describe(), {
             'has': {
                 'ws': True,
@@ -26,7 +26,9 @@ class whitebit(ccxt.async_support.whitebit):
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': True,
+                'watchTickers': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
             },
             'urls': {
                 'api': {
@@ -67,6 +69,9 @@ class whitebit(ccxt.async_support.whitebit):
     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
+
+        https://docs.whitebit.com/public/websocket/#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
@@ -135,6 +140,9 @@ class whitebit(ccxt.async_support.whitebit):
     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
+
+        https://docs.whitebit.com/public/websocket/#market-depth
+
         :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
@@ -233,6 +241,9 @@ class whitebit(ccxt.async_support.whitebit):
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+
+        https://docs.whitebit.com/public/websocket/#market-statistics
+
         :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>`
@@ -245,6 +256,35 @@ 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
+
+        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):
         #
         #   {
@@ -295,6 +335,9 @@ class whitebit(ccxt.async_support.whitebit):
     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
+
+        https://docs.whitebit.com/public/websocket/#market-trades
+
         :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
@@ -356,6 +399,9 @@ class whitebit(ccxt.async_support.whitebit):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches trades made by the user
+
+        https://docs.whitebit.com/private/websocket/#deals
+
         :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
@@ -449,11 +495,14 @@ class whitebit(ccxt.async_support.whitebit):
     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
+
+        https://docs.whitebit.com/private/websocket/#orders-pending
+
         :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
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
             raise ArgumentsRequired(self.id + ' watchOrders() requires a symbol argument')
@@ -612,6 +661,10 @@ class whitebit(ccxt.async_support.whitebit):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
+
+        https://docs.whitebit.com/private/websocket/#balance-spot
+        https://docs.whitebit.com/private/websocket/#balance-margin
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.type]: spot or contract if not provided self.options['defaultType'] is used
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -781,7 +834,7 @@ class whitebit(ccxt.async_support.whitebit):
         future.resolve(1)
         return message
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         #     {
         #         "error": {code: 1, message: "invalid argument"},
@@ -856,7 +909,7 @@ class whitebit(ccxt.async_support.whitebit):
         client.lastPong = self.milliseconds()
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'id': 0,
             'method': 'ping',