ccxt 4.4.31__py2.py3-none-any.whl → 4.4.33__py2.py3-none-any.whl

ccxt/pro/bitget.py

@@ -431,7 +431,7 @@ class bitget(ccxt.async_support.bitget):
         https://www.bitget.com/api-doc/contract/websocket/public/Candlesticks-Channel
 
         :param str symbol: unified symbol of the market to unwatch the ohlcv for
-        :param str timeframe:
+        :param str [timeframe]: the period for the ratio, default is 1 minute
         :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
         """
@@ -664,7 +664,7 @@ class bitget(ccxt.async_support.bitget):
             self.handle_deltas(storedOrderBook['bids'], bids)
             storedOrderBook['timestamp'] = timestamp
             storedOrderBook['datetime'] = self.iso8601(timestamp)
-            checksum = self.safe_bool(self.options, 'checksum', True)
+            checksum = self.handle_option('watchOrderBook', 'checksum', True)
             isSnapshot = self.safe_string(message, 'action') == 'snapshot'  # snapshot does not have a checksum
             if not isSnapshot and checksum:
                 storedAsks = storedOrderBook['asks']
@@ -916,8 +916,8 @@ class bitget(ccxt.async_support.bitget):
         https://www.bitget.com/api-doc/contract/websocket/private/Positions-Channel
 
         :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :param str [params.instType]: one of 'USDT-FUTURES', 'USDC-FUTURES', 'COIN-FUTURES', 'SUSDT-FUTURES', 'SUSDC-FUTURES' or 'SCOIN-FUTURES', default is 'USDT-FUTURES'
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`

ccxt/pro/bitmart.py

@@ -695,8 +695,8 @@ class bitmart(ccxt.async_support.bitmart):
 
         watch all open positions
         :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param int [since]: the earliest time in ms to fetch positions
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/bitmex.py

@@ -718,8 +718,8 @@ class bitmex(ccxt.async_support.bitmex):
         https://www.bitmex.com/app/wsAPI#Subscriptions
 
         :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param int [since]: the earliest time in ms to watch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/bitvavo.py

@@ -306,10 +306,9 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        ]
         #    }
         #
-        action = self.safe_string(message, 'action')
         response = self.safe_value(message, 'response')
         ohlcv = self.parse_ohlcvs(response, None, None, None)
-        messageHash = self.build_message_hash(action)
+        messageHash = self.safe_string(message, 'requestId')
         client.resolve(ohlcv, messageHash)
 
     def handle_ohlcv(self, client: Client, message):
@@ -687,14 +686,15 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        }]
         #    }
         #
-        action = self.safe_string(message, 'action')
-        response = self.safe_value(message, 'response')
-        firstRawOrder = self.safe_value(response, 0, {})
-        marketId = self.safe_string(firstRawOrder, 'market')
+        # action = self.safe_string(message, 'action')
+        response = self.safe_list(message, 'response')
+        # firstRawOrder = self.safe_value(response, 0, {})
+        # marketId = self.safe_string(firstRawOrder, 'market')
         orders = self.parse_orders(response)
-        messageHash = self.build_message_hash(action, {'market': marketId})
-        client.resolve(orders, messageHash)
-        messageHash = self.build_message_hash(action, message)
+        # messageHash = self.build_message_hash(action, {'market': marketId})
+        # client.resolve(orders, messageHash)
+        # messageHash = self.build_message_hash(action, message)
+        messageHash = self.safe_string(message, 'requestId')
         client.resolve(orders, messageHash)
 
     async def fetch_order_ws(self, id: str, symbol: Str = None, params={}) -> Order:
@@ -739,13 +739,19 @@ class bitvavo(ccxt.async_support.bitvavo):
         orders = await self.watch_request('privateGetOrders', request)
         return self.filter_by_symbol_since_limit(orders, symbol, since, limit)
 
+    def request_id(self):
+        ts = str(self.milliseconds())
+        randomNumber = self.rand_number(4)
+        randomPart = str(randomNumber)
+        return int(ts + randomPart)
+
     async def watch_request(self, action, request):
+        messageHash = self.request_id()
+        messageHashStr = str(messageHash)
         request['action'] = action
-        messageHash = self.build_message_hash(action, request)
-        self.check_message_hash_does_not_exist(messageHash)
+        request['requestId'] = messageHash
         url = self.urls['api']['ws']
-        randomSubHash = str(self.rand_number(5)) + ':' + messageHash
-        return await self.watch(url, messageHash, request, randomSubHash)
+        return await self.watch(url, messageHashStr, request, messageHashStr)
 
     async def fetch_open_orders_ws(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
@@ -810,12 +816,12 @@ class bitvavo(ccxt.async_support.bitvavo):
         #    }
         #
         #
-        action = self.safe_string(message, 'action')
-        response = self.safe_value(message, 'response')
-        firstRawTrade = self.safe_value(response, 0, {})
-        marketId = self.safe_string(firstRawTrade, 'market')
+        # action = self.safe_string(message, 'action')
+        response = self.safe_list(message, 'response')
+        # marketId = self.safe_string(firstRawTrade, 'market')
         trades = self.parse_trades(response, None, None, None)
-        messageHash = self.build_message_hash(action, {'market': marketId})
+        # messageHash = self.build_message_hash(action, {'market': marketId})
+        messageHash = self.safe_string(message, 'requestId')
         client.resolve(trades, messageHash)
 
     async def withdraw_ws(self, code: str, amount, address, tag=None, params={}):
@@ -846,8 +852,9 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        }
         #    }
         #
-        action = self.safe_string(message, 'action')
-        messageHash = self.build_message_hash(action, message)
+        # action = self.safe_string(message, 'action')
+        # messageHash = self.build_message_hash(action, message)
+        messageHash = self.safe_string(message, 'requestId')
         response = self.safe_value(message, 'response')
         withdraw = self.parse_transaction(response)
         client.resolve(withdraw, messageHash)
@@ -886,9 +893,10 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        ]
         #    }
         #
-        action = self.safe_string(message, 'action')
-        messageHash = self.build_message_hash(action, message)
-        response = self.safe_value(message, 'response')
+        # action = self.safe_string(message, 'action')
+        # messageHash = self.build_message_hash(action, message)
+        response = self.safe_list(message, 'response')
+        messageHash = self.safe_string(message, 'requestId')
         withdrawals = self.parse_transactions(response, None, None, None, {'type': 'withdrawal'})
         client.resolve(withdrawals, messageHash)
 
@@ -945,10 +953,9 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        ]
         #    }
         #
-        action = self.safe_string(message, 'action')
-        messageHash = self.build_message_hash(action, message)
         response = self.safe_value(message, 'response')
         deposits = self.parse_transactions(response, None, None, None, {'type': 'deposit'})
+        messageHash = self.safe_string(message, 'requestId')
         client.resolve(deposits, messageHash)
 
     async def fetch_trading_fees_ws(self, params={}) -> TradingFees:
@@ -1008,8 +1015,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        ]
         #    }
         #
-        action = self.safe_string(message, 'action')
-        messageHash = self.build_message_hash(action, message)
+        messageHash = self.safe_string(message, 'requestId')
         response = self.safe_value(message, 'response')
         currencies = self.parse_currencies(response)
         client.resolve(currencies, messageHash)
@@ -1027,8 +1033,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        }
         #    }
         #
-        action = self.safe_string(message, 'action')
-        messageHash = self.build_message_hash(action, message)
+        messageHash = self.safe_string(message, 'requestId')
         response = self.safe_value(message, 'response')
         fees = self.parse_trading_fees(response)
         client.resolve(fees, messageHash)
@@ -1059,8 +1064,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        ]
         #    }
         #
-        action = self.safe_string(message, 'action', 'privateGetBalance')
-        messageHash = self.build_message_hash(action, message)
+        messageHash = self.safe_string(message, 'requestId')
         response = self.safe_value(message, 'response', [])
         balance = self.parse_balance(response)
         client.resolve(balance, messageHash)
@@ -1094,10 +1098,9 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        }
         #    }
         #
-        action = self.safe_string(message, 'action')
         response = self.safe_value(message, 'response', {})
         order = self.parse_order(response)
-        messageHash = self.build_message_hash(action, response)
+        messageHash = self.safe_string(message, 'requestId')
         client.resolve(order, messageHash)
 
     def handle_markets(self, client: Client, message):
@@ -1120,10 +1123,9 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        ]
         #    }
         #
-        action = self.safe_string(message, 'action')
         response = self.safe_value(message, 'response', {})
         markets = self.parse_markets(response)
-        messageHash = self.build_message_hash(action, response)
+        messageHash = self.safe_string(message, 'requestId')
         client.resolve(markets, messageHash)
 
     def build_message_hash(self, action, params={}):
@@ -1140,15 +1142,6 @@ class bitvavo(ccxt.async_support.bitvavo):
             messageHash = method(action, params)
         return messageHash
 
-    def check_message_hash_does_not_exist(self, messageHash):
-        supressMultipleWsRequestsError = self.safe_bool(self.options, 'supressMultipleWsRequestsError', False)
-        if not supressMultipleWsRequestsError:
-            client = self.safe_value(self.clients, self.urls['api']['ws'])
-            if client is not None:
-                future = self.safe_value(client.futures, messageHash)
-                if future is not None:
-                    raise ExchangeError(self.id + ' a similar request with messageHash ' + messageHash + ' is already pending, you must wait for a response, or turn off self error by setting supressMultipleWsRequestsError in the options to True')
-
     def action_and_market_message_hash(self, action, params={}):
         symbol = self.safe_string(params, 'market', '')
         return action + symbol
@@ -1292,11 +1285,19 @@ class bitvavo(ccxt.async_support.bitvavo):
         #        errorCode: 217,
         #        error: 'Minimum order size in quote currency is 5 EUR or 0.001 BTC.'
         #    }
+        #    {
+        #        action: 'privateCreateOrder',
+        #        requestId: '17317539426571916',
+        #        market: 'USDT-EUR',
+        #        errorCode: 216,
+        #        error: 'You do not have sufficient balance to complete self operation.'
+        #    }
         #
         error = self.safe_string(message, 'error')
         code = self.safe_integer(error, 'errorCode')
         action = self.safe_string(message, 'action')
-        messageHash = self.build_message_hash(action, message)
+        buildMessage = self.build_message_hash(action, message)
+        messageHash = self.safe_string(message, 'requestId', buildMessage)
         rejected = False
         try:
             self.handle_errors(code, error, client.url, None, None, error, message, None, None)

ccxt/pro/blofin.py

@@ -525,8 +525,8 @@ class blofin(ccxt.async_support.blofin):
 
         watch all open positions
         :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/bybit.py

@@ -1331,8 +1331,8 @@ class bybit(ccxt.async_support.bybit):
 
         watch all open positions
         :param str[] [symbols]: list of unified market symbols
- @param since
- @param limit
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/cryptocom.py

@@ -349,7 +349,7 @@ class cryptocom(ccxt.async_support.cryptocom):
 
         https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#trade-instrument_name
 
- @param symbols
+        :param str[] [symbols]: list of unified market symbols to unwatch trades for
         :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>`
         """
@@ -815,9 +815,9 @@ class cryptocom(ccxt.async_support.cryptocom):
 
         https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#user-position_balance
 
-        :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param str[] [symbols]: list of unified market symbols to watch positions for
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/gate.py

@@ -336,7 +336,7 @@ class gate(ccxt.async_support.gate):
         https://www.gate.io/docs/developers/futures/ws/en/#order-list
 
         fetches information on multiple orders made by the user by status
- @param status
+        :param str status: requested order status
         :param str symbol: unified market symbol of the market orders were made in
         :param int|None [since]: the earliest time in ms to fetch orders for
         :param int|None [limit]: the maximum number of order structures to retrieve
@@ -1067,9 +1067,9 @@ class gate(ccxt.async_support.gate):
         https://www.gate.io/docs/developers/options/ws/en/#positions-channel
 
         watch all open positions
-        :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param str[] [symbols]: list of unified market symbols to watch positions for
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/hashkey.py

@@ -573,9 +573,9 @@ class hashkey(ccxt.async_support.hashkey):
         https://hashkeyglobal-apidoc.readme.io/reference/websocket-api#private-stream
 
         watch all open positions
-        :param str[]|None symbols: list of unified market symbols
- @param since
- @param limit
+        :param str[] [symbols]: list of unified market symbols to watch positions for
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """

ccxt/pro/mexc.py

@@ -1248,8 +1248,7 @@ class mexc(ccxt.async_support.mexc):
             '2': 'closed',   # filled
             '3': 'open',     # partially filled
             '4': 'canceled',  # canceled
-            '5': 'open',     # order partially filled
-            '6': 'closed',   # partially filled then canceled
+            '5': 'closed',   # partially filled then canceled
             'NEW': 'open',
             'CANCELED': 'canceled',
             'EXECUTED': 'closed',

ccxt/pro/okx.py

@@ -2135,6 +2135,7 @@ class okx(ccxt.async_support.okx):
         #
         #     {event: 'error', msg: "Illegal request: {"op":"subscribe","args":["spot/ticker:BTC-USDT"]}", code: "60012"}
         #     {event: 'error", msg: "channel:ticker,instId:BTC-USDT doesn"t exist", code: "60018"}
+        #     {"event":"error","msg":"Illegal request: {\\"id\\":\\"17321173472466905\\",\\"op\\":\\"amend-order\\",\\"args\\":[{\\"instId\\":\\"ETH-USDC\\",\\"ordId\\":\\"2000345622407479296\\",\\"newSz\\":\\"0.050857\\",\\"newPx\\":\\"2949.4\\",\\"postOnly\\":true}],\\"postOnly\\":true}","code":"60012","connId":"0808af6c"}
         #
         errorCode = self.safe_string(message, 'code')
         try:
@@ -2160,6 +2161,13 @@ class okx(ccxt.async_support.okx):
             # if the message contains an id, it means it is a response to a request
             # so we only reject that promise, instead of deleting all futures, destroying the authentication future
             id = self.safe_string(message, 'id')
+            if id is None:
+                # try to parse it from the stringified json inside msg
+                msg = self.safe_string(message, 'msg')
+                if msg is not None and msg.startswith('Illegal request: {'):
+                    stringifiedJson = msg.replace('Illegal request: ', '')
+                    parsedJson = self.parse_json(stringifiedJson)
+                    id = self.safe_string(parsedJson, 'id')
             if id is not None:
                 client.reject(e, id)
                 return False

ccxt/test/tests_async.py

@@ -183,6 +183,7 @@ class testMainClass:
         is_load_markets = (method_name == 'loadMarkets')
         is_fetch_currencies = (method_name == 'fetchCurrencies')
         is_proxy_test = (method_name == self.proxy_test_file_name)
+        is_feature_test = (method_name == 'features')
         # if this is a private test, and the implementation was already tested in public, then no need to re-test it in private test (exception is fetchCurrencies, because our approach in base exchange)
         if not is_public and (method_name in self.checked_public_tests) and not is_fetch_currencies:
             return
@@ -190,7 +191,7 @@ class testMainClass:
         supported_by_exchange = (method_name in exchange.has) and exchange.has[method_name]
         if not is_load_markets and (len(self.only_specific_tests) > 0 and not exchange.in_array(method_name, self.only_specific_tests)):
             skip_message = '[INFO] IGNORED_TEST'
-        elif not is_load_markets and not supported_by_exchange and not is_proxy_test:
+        elif not is_load_markets and not supported_by_exchange and not is_proxy_test and not is_feature_test:
             skip_message = '[INFO] UNSUPPORTED_TEST'  # keep it aligned with the longest message
         elif isinstance(skipped_properties_for_method, str):
             skip_message = '[INFO] SKIPPED_TEST'
@@ -336,6 +337,7 @@ class testMainClass:
 
     async def run_public_tests(self, exchange, symbol):
         tests = {
+            'features': [],
             'fetchCurrencies': [],
             'fetchTicker': [symbol],
             'fetchTickers': [symbol],

ccxt/test/tests_helpers.py

@@ -228,7 +228,7 @@ def init_exchange(exchangeId, args, is_ws=False):
 
 def get_test_files_sync(properties, ws=False):
     tests = {}
-    finalPropList = properties + [PROXY_TEST_FILE_NAME]
+    finalPropList = properties + [PROXY_TEST_FILE_NAME, 'features']
     for i in range(0, len(finalPropList)):
         methodName = finalPropList[i]
         name_snake_case = convert_to_snake_case(methodName)

ccxt/test/tests_sync.py

@@ -180,6 +180,7 @@ class testMainClass:
         is_load_markets = (method_name == 'loadMarkets')
         is_fetch_currencies = (method_name == 'fetchCurrencies')
         is_proxy_test = (method_name == self.proxy_test_file_name)
+        is_feature_test = (method_name == 'features')
         # if this is a private test, and the implementation was already tested in public, then no need to re-test it in private test (exception is fetchCurrencies, because our approach in base exchange)
         if not is_public and (method_name in self.checked_public_tests) and not is_fetch_currencies:
             return
@@ -187,7 +188,7 @@ class testMainClass:
         supported_by_exchange = (method_name in exchange.has) and exchange.has[method_name]
         if not is_load_markets and (len(self.only_specific_tests) > 0 and not exchange.in_array(method_name, self.only_specific_tests)):
             skip_message = '[INFO] IGNORED_TEST'
-        elif not is_load_markets and not supported_by_exchange and not is_proxy_test:
+        elif not is_load_markets and not supported_by_exchange and not is_proxy_test and not is_feature_test:
             skip_message = '[INFO] UNSUPPORTED_TEST'  # keep it aligned with the longest message
         elif isinstance(skipped_properties_for_method, str):
             skip_message = '[INFO] SKIPPED_TEST'
@@ -333,6 +334,7 @@ class testMainClass:
 
     def run_public_tests(self, exchange, symbol):
         tests = {
+            'features': [],
             'fetchCurrencies': [],
             'fetchTicker': [symbol],
             'fetchTickers': [symbol],

ccxt/wavesexchange.py

@@ -1889,6 +1889,9 @@ class wavesexchange(Exchange, ImplicitAPI):
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user
+
+        https://api.wavesplatform.com/v0/docs/#/transactions/searchTxsExchange
+
         :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

ccxt/woofipro.py

@@ -2379,8 +2379,8 @@ class woofipro(Exchange, ImplicitAPI):
 
         https://orderly.network/docs/build-on-evm/evm-api/restful-api/private/update-leverage-setting
 
- @param leverage
-        :param str symbol: unified market symbol
+        :param int [leverage]: the rate of leverage
+        :param str [symbol]: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: response from the exchange
         """

{ccxt-4.4.31.dist-info → ccxt-4.4.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.31
+Version: 4.4.33
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -273,13 +273,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.31/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.31/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.33/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.33/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.31/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.33/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object:
@@ -307,6 +307,12 @@ The library supports concurrent asynchronous mode with asyncio and async/await i
 import ccxt.async_support as ccxt # link against the asynchronous version of ccxt
 ```
 
+#### orjson support
+
+CCXT also supports `orjson` for parsing JSON since it is much faster than the builtin library. This is especially important when using websockets because some exchanges return big messages that need to be parsed and dispatched as quickly as possible.
+
+However, `orjson` is not enabled by default because it is not supported by every python interpreter. If you want to opt-in, you just need to install it (`pip install orjson`) on your local environment. CCXT will detect the installion and pick it up automatically.
+
 ### PHP
 
 [ccxt in PHP with **Packagist/Composer**](https://packagist.org/packages/ccxt/ccxt) (PHP 7.0+)