ccxt 4.3.19__py2.py3-none-any.whl → 4.3.21__py2.py3-none-any.whl

ccxt/phemex.py

@@ -2347,12 +2347,14 @@ class phemex(Exchange, ImplicitAPI):
         """
         create a trade order
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#place-order
+        :see: https://phemex-docs.github.io/#place-order-http-put-prefered-3
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
         :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.trigger]: trigger price for conditional orders
         :param dict [params.takeProfit]: *swap only* *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered(perpetual swap markets only)
         :param float [params.takeProfit.triggerPrice]: take profit trigger price
         :param dict [params.stopLoss]: *swap only* *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered(perpetual swap markets only)
@@ -2363,7 +2365,7 @@ class phemex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         requestSide = self.capitalize(side)
         type = self.capitalize(type)
-        reduceOnly = self.safe_value(params, 'reduceOnly')
+        reduceOnly = self.safe_bool(params, 'reduceOnly')
         request = {
             # common
             'symbol': market['id'],
@@ -2404,18 +2406,24 @@ class phemex(Exchange, ImplicitAPI):
         else:
             request['clOrdID'] = clientOrderId
             params = self.omit(params, ['clOrdID', 'clientOrderId'])
-        stopPrice = self.safe_string_n(params, ['stopPx', 'stopPrice', 'triggerPrice'])
-        if stopPrice is not None:
+        triggerPrice = self.safe_string_n(params, ['stopPx', 'stopPrice', 'triggerPrice'])
+        if triggerPrice is not None:
             if market['settle'] == 'USDT':
-                request['stopPxRp'] = self.price_to_precision(symbol, stopPrice)
+                request['stopPxRp'] = self.price_to_precision(symbol, triggerPrice)
             else:
-                request['stopPxEp'] = self.to_ep(stopPrice, market)
+                request['stopPxEp'] = self.to_ep(triggerPrice, market)
         params = self.omit(params, ['stopPx', 'stopPrice', 'stopLoss', 'takeProfit', 'triggerPrice'])
         if market['spot']:
             qtyType = self.safe_value(params, 'qtyType', 'ByBase')
             if (type == 'Market') or (type == 'Stop') or (type == 'MarketIfTouched'):
                 if price is not None:
                     qtyType = 'ByQuote'
+            if triggerPrice is not None:
+                if type == 'Limit':
+                    request['ordType'] = 'StopLimit'
+                elif type == 'Market':
+                    request['ordType'] = 'Stop'
+                request['trigger'] = 'ByLastPrice'
             request['qtyType'] = qtyType
             if qtyType == 'ByQuote':
                 cost = self.safe_number(params, 'cost')
@@ -2446,7 +2454,7 @@ class phemex(Exchange, ImplicitAPI):
                 request['orderQtyRq'] = amount
             else:
                 request['orderQty'] = self.parse_to_int(amount)
-            if stopPrice is not None:
+            if triggerPrice is not None:
                 triggerType = self.safe_string(params, 'triggerType', 'ByMarkPrice')
                 request['triggerType'] = triggerType
             if stopLossDefined or takeProfitDefined:
@@ -3782,7 +3790,7 @@ class phemex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "code": 0,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.19'
+__version__ = '4.3.21'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/htx.py

@@ -1772,7 +1772,7 @@ class htx(ccxt.async_support.htx):
         #        "data": {"user-id": "35930539"}
         #    }
         #
-        promise = client.futures['authenticated']
+        promise = client.futures['auth']
         promise.resolve(message)
 
     def handle_error_message(self, client: Client, message):
@@ -1800,6 +1800,12 @@ class htx(ccxt.async_support.htx):
         #         'err-msg': "Non - single account user is not available, please check through the cross and isolated account asset interface",
         #         "ts": 1698419490189
         #     }
+        #     {
+        #         "action":"req",
+        #         "code":2002,
+        #         "ch":"auth",
+        #         "message":"auth.fail"
+        #     }
         #
         status = self.safe_string(message, 'status')
         if status == 'error':
@@ -1810,6 +1816,7 @@ class htx(ccxt.async_support.htx):
                 errorCode = self.safe_string(message, 'err-code')
                 try:
                     self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], errorCode, self.json(message))
+                    raise ExchangeError(self.json(message))
                 except Exception as e:
                     messageHash = self.safe_string(subscription, 'messageHash')
                     client.reject(e, messageHash)
@@ -1817,11 +1824,12 @@ class htx(ccxt.async_support.htx):
                     if id in client.subscriptions:
                         del client.subscriptions[id]
             return False
-        code = self.safe_integer_2(message, 'code', 'err-code')
-        if code is not None and ((code != 200) and (code != 0)):
+        code = self.safe_string_2(message, 'code', 'err-code')
+        if code is not None and ((code != '200') and (code != '0')):
             feedback = self.id + ' ' + self.json(message)
             try:
                 self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], code, feedback)
+                raise ExchangeError(feedback)
             except Exception as e:
                 if isinstance(e, AuthenticationError):
                     client.reject(e, 'auth')
@@ -2137,8 +2145,6 @@ class htx(ccxt.async_support.htx):
             'url': url,
             'hostname': hostname,
         }
-        if type == 'spot':
-            self.options['ws']['gunzip'] = False
         await self.authenticate(authParams)
         return await self.watch(url, messageHash, self.extend(request, params), channel, extendedSubsription)
 
@@ -2149,7 +2155,7 @@ class htx(ccxt.async_support.htx):
         if url is None or hostname is None or type is None:
             raise ArgumentsRequired(self.id + ' authenticate requires a url, hostname and type argument')
         self.check_required_credentials()
-        messageHash = 'authenticated'
+        messageHash = 'auth'
         relativePath = url.replace('wss://' + hostname, '')
         client = self.client(url)
         future = client.future(messageHash)

ccxt/pro/kucoinfutures.py

@@ -4,7 +4,7 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 import ccxt.async_support
-from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
@@ -22,6 +22,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
                 'watchTickers': True,
                 'watchBidsAsks': True,
                 'watchTrades': True,
+                'watchOHLCV': True,
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchBalance': True,
@@ -32,6 +33,21 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
                 'watchOrderBookForSymbols': True,
             },
             'options': {
+                'timeframes': {
+                    '1m': '1min',
+                    '3m': '1min',
+                    '5m': '5min',
+                    '15m': '15min',
+                    '30m': '30min',
+                    '1h': '1hour',
+                    '2h': '2hour',
+                    '4h': '4hour',
+                    '8h': '8hour',
+                    '12h': '12hour',
+                    '1d': '1day',
+                    '1w': '1week',
+                    '1M': '1month',
+                },
                 'accountsByType': {
                     'swap': 'future',
                     'cross': 'margin',
@@ -540,6 +556,77 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         client.resolve(trades, messageHash)
         return message
 
+    async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/klines
+        watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        symbol = self.symbol(symbol)
+        url = await self.negotiate(False)
+        marketId = self.market_id(symbol)
+        timeframes = self.safe_dict(self.options, 'timeframes')
+        timeframeId = self.safe_string(timeframes, timeframe, timeframe)
+        topic = '/contractMarket/limitCandle:' + marketId + '_' + timeframeId
+        messageHash = 'ohlcv::' + symbol + '_' + timeframe
+        ohlcv = await self.subscribe(url, messageHash, topic, None, params)
+        if self.newUpdates:
+            limit = ohlcv.getLimit(symbol, limit)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
+
+    def handle_ohlcv(self, client: Client, message):
+        #
+        #    {
+        #        "topic":"/contractMarket/limitCandle:LTCUSDTM_1min",
+        #        "type":"message",
+        #        "data":{
+        #            "symbol":"LTCUSDTM",
+        #            "candles":[
+        #                "1715470980",
+        #                "81.38",
+        #                "81.38",
+        #                "81.38",
+        #                "81.38",
+        #                "61.0",
+        #                "61"
+        #            ],
+        #            "time":1715470994801
+        #        },
+        #        "subject":"candle.stick"
+        #    }
+        #
+        topic = self.safe_string(message, 'topic')
+        parts = topic.split('_')
+        timeframeId = self.safe_string(parts, 1)
+        data = self.safe_dict(message, 'data')
+        timeframes = self.safe_dict(self.options, 'timeframes')
+        timeframe = self.find_timeframe(timeframeId, timeframes)
+        marketId = self.safe_string(data, 'symbol')
+        symbol = self.safe_symbol(marketId)
+        messageHash = 'ohlcv::' + symbol + '_' + timeframe
+        ohlcv = self.safe_list(data, 'candles')
+        parsed = [
+            self.safe_integer(ohlcv, 0),
+            self.safe_number(ohlcv, 1),
+            self.safe_number(ohlcv, 2),
+            self.safe_number(ohlcv, 3),
+            self.safe_number(ohlcv, 4),
+            self.safe_number(ohlcv, 6),  # Note value 5 is incorrect and will be fixed in subsequent versions of kucoin
+        ]
+        self.ohlcvs[symbol] = self.safe_dict(self.ohlcvs, symbol, {})
+        if not (timeframe in self.ohlcvs[symbol]):
+            limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
+            self.ohlcvs[symbol][timeframe] = ArrayCacheByTimestamp(limit)
+        stored = self.ohlcvs[symbol][timeframe]
+        stored.append(parsed)
+        client.resolve(stored, messageHash)
+
     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
@@ -923,6 +1010,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         methods = {
             'level2': self.handle_order_book,
             'ticker': self.handle_ticker,
+            'candle.stick': self.handle_ohlcv,
             'tickerV2': self.handle_bid_ask,
             'availableBalance.change': self.handle_balance,
             'match': self.handle_trade,

ccxt/pro/woo.py

@@ -531,6 +531,16 @@ class woo(ccxt.async_support.woo):
         request = self.extend(subscribe, message)
         return await self.watch(url, messageHash, request, messageHash, subscribe)
 
+    async def watch_private_multiple(self, messageHashes, message, params={}):
+        await self.authenticate(params)
+        url = self.urls['api']['ws']['private'] + '/' + self.uid
+        requestId = self.request_id(url)
+        subscribe = {
+            'id': requestId,
+        }
+        request = self.extend(subscribe, message)
+        return await self.watch_multiple(url, messageHashes, request, messageHashes, subscribe)
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         :see: https://docs.woo.org/#executionreport
@@ -540,10 +550,13 @@ class woo(ccxt.async_support.woo):
         :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
+        :param bool [params.trigger]: True if trigger order
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        topic = 'executionreport'
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
+        topic = 'algoexecutionreportv2' if (trigger) else 'executionreport'
+        params = self.omit(params, ['stop', 'trigger'])
         messageHash = topic
         if symbol is not None:
             market = self.market(symbol)
@@ -562,15 +575,19 @@ class woo(ccxt.async_support.woo):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         :see: https://docs.woo.org/#executionreport
+        :see: https://docs.woo.org/#algoexecutionreportv2
         watches information on multiple trades made by the user
         :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
+        :param bool [params.trigger]: True if trigger order
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        topic = 'executionreport'
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
+        topic = 'algoexecutionreportv2' if (trigger) else 'executionreport'
+        params = self.omit(params, ['stop', 'trigger'])
         messageHash = 'myTrades'
         if symbol is not None:
             market = self.market(symbol)
@@ -692,14 +709,24 @@ class woo(ccxt.async_support.woo):
         #         }
         #     }
         #
-        order = self.safe_dict(message, 'data')
-        tradeId = self.safe_string(order, 'tradeId')
-        if (tradeId is not None) and (tradeId != '0'):
-            self.handle_my_trade(client, order)
-        self.handle_order(client, order)
+        topic = self.safe_string(message, 'topic')
+        data = self.safe_value(message, 'data')
+        if isinstance(data, list):
+            # algoexecutionreportv2
+            for i in range(0, len(data)):
+                order = data[i]
+                tradeId = self.omit_zero(self.safe_string(data, 'tradeId'))
+                if tradeId is not None:
+                    self.handle_my_trade(client, order)
+                self.handle_order(client, order, topic)
+        else:
+            # executionreport
+            tradeId = self.omit_zero(self.safe_string(data, 'tradeId'))
+            if tradeId is not None:
+                self.handle_my_trade(client, data)
+            self.handle_order(client, data, topic)
 
-    def handle_order(self, client: Client, message):
-        topic = 'executionreport'
+    def handle_order(self, client: Client, message, topic):
         parsed = self.parse_ws_order(message)
         symbol = self.safe_string(parsed, 'symbol')
         orderId = self.safe_string(parsed, 'id')
@@ -776,11 +803,14 @@ class woo(ccxt.async_support.woo):
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """
         await self.load_markets()
-        messageHash = ''
+        messageHashes = []
         symbols = self.market_symbols(symbols)
         if not self.is_empty(symbols):
-            messageHash = '::' + ','.join(symbols)
-        messageHash = 'positions' + messageHash
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append('positions::' + symbol)
+        else:
+            messageHashes.append('positions')
         url = self.urls['api']['ws']['private'] + '/' + self.uid
         client = self.client(url)
         self.set_positions_cache(client, symbols)
@@ -793,7 +823,7 @@ class woo(ccxt.async_support.woo):
             'event': 'subscribe',
             'topic': 'position',
         }
-        newPositions = await self.watch_private(messageHash, request, params)
+        newPositions = await self.watch_private_multiple(messageHashes, request, params)
         if self.newUpdates:
             return newPositions
         return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit, True)
@@ -862,15 +892,8 @@ class woo(ccxt.async_support.woo):
             position = self.parse_position(rawPosition, market)
             newPositions.append(position)
             cache.append(position)
-        messageHashes = self.find_message_hashes(client, 'positions::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            positions = self.filter_by_array(newPositions, 'symbol', symbols, False)
-            if not self.is_empty(positions):
-                client.resolve(positions, messageHash)
+            messageHash = 'positions::' + market['symbol']
+            client.resolve(position, messageHash)
         client.resolve(newPositions, 'positions')
 
     async def watch_balance(self, params={}) -> Balances:
@@ -978,6 +1001,7 @@ class woo(ccxt.async_support.woo):
             'kline': self.handle_ohlcv,
             'auth': self.handle_auth,
             'executionreport': self.handle_order_update,
+            'algoexecutionreportv2': self.handle_order_update,
             'trade': self.handle_trade,
             'balance': self.handle_balance,
             'position': self.handle_positions,

{ccxt-4.3.19.dist-info → ccxt-4.3.21.dist-info}/METADATA

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