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

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/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.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.31
+Version: 4.4.32
 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.32/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.32/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.32/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+)