ccxt 4.4.34__py2.py3-none-any.whl → 4.4.35__py2.py3-none-any.whl

ccxt/pro/probit.py

@@ -41,15 +41,6 @@ class probit(ccxt.async_support.probit):
                     'filter': 'order_books_l2',
                     'interval': 100,  # or 500
                 },
-                'watchTrades': {
-                    'filter': 'recent_trades',
-                },
-                'watchTicker': {
-                    'filter': 'ticker',
-                },
-                'watchOrders': {
-                    'channel': 'open_order',
-                },
             },
             'streaming': {
             },
@@ -66,13 +57,7 @@ class probit(ccxt.async_support.probit):
         """
         await self.authenticate(params)
         messageHash = 'balance'
-        url = self.urls['api']['ws']
-        subscribe: dict = {
-            'type': 'subscribe',
-            'channel': 'balance',
-        }
-        request = self.extend(subscribe, params)
-        return await self.watch(url, messageHash, request, messageHash)
+        return await self.subscribe_private(messageHash, 'balance', params)
 
     def handle_balance(self, client: Client, message):
         #
@@ -130,9 +115,8 @@ class probit(ccxt.async_support.probit):
         :param int [params.interval]: Unit time to synchronize market information(ms). Available units: 100, 500
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        filter = None
-        filter, params = self.handle_option_and_params(params, 'watchTicker', 'filter', 'ticker')
-        return await self.subscribe_order_book(symbol, 'ticker', filter, params)
+        channel = 'ticker'
+        return await self.subscribe_public('watchTicker', symbol, 'ticker', channel, params)
 
     def handle_ticker(self, client: Client, message):
         #
@@ -175,9 +159,8 @@ class probit(ccxt.async_support.probit):
         :param int [params.interval]: Unit time to synchronize market information(ms). Available units: 100, 500
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
-        filter = None
-        filter, params = self.handle_option_and_params(params, 'watchTrades', 'filter', 'recent_trades')
-        trades = await self.subscribe_order_book(symbol, 'trades', filter, params)
+        channel = 'recent_trades'
+        trades = await self.subscribe_public('watchTrades', symbol, 'trades', channel, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
@@ -207,10 +190,11 @@ class probit(ccxt.async_support.probit):
         symbol = self.safe_symbol(marketId)
         market = self.safe_market(marketId)
         trades = self.safe_value(message, 'recent_trades', [])
-        reset = self.safe_bool(message, 'reset', False)
+        if self.safe_bool(message, 'reset', False):
+            return  # see comment in handleMessage
         messageHash = 'trades:' + symbol
         stored = self.safe_value(self.trades, symbol)
-        if stored is None or reset:
+        if stored is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCache(limit)
             self.trades[symbol] = stored
@@ -235,19 +219,11 @@ class probit(ccxt.async_support.probit):
         """
         await self.load_markets()
         await self.authenticate(params)
-        messageHash = 'myTrades'
+        messageHash = 'trades'
         if symbol is not None:
-            market = self.market(symbol)
-            symbol = market['symbol']
+            symbol = self.safe_symbol(symbol)
             messageHash = messageHash + ':' + symbol
-        url = self.urls['api']['ws']
-        channel = 'trade_history'
-        message: dict = {
-            'type': 'subscribe',
-            'channel': channel,
-        }
-        request = self.extend(message, params)
-        trades = await self.watch(url, messageHash, request, channel)
+        trades = await self.subscribe_private(messageHash, 'trade_history', params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
@@ -276,10 +252,11 @@ class probit(ccxt.async_support.probit):
         length = len(rawTrades)
         if length == 0:
             return
-        reset = self.safe_bool(message, 'reset', False)
-        messageHash = 'myTrades'
+        if self.safe_bool(message, 'reset', False):
+            return  # see comment in handleMessage
+        messageHash = 'trades'
         stored = self.myTrades
-        if (stored is None) or reset:
+        if stored is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCacheBySymbolById(limit)
             self.myTrades = stored
@@ -287,9 +264,15 @@ class probit(ccxt.async_support.probit):
         tradeSymbols: dict = {}
         for j in range(0, len(trades)):
             trade = trades[j]
+            # don't include 'executed' state, because it's just blanket state of the trade, emited before actual trade event
+            if self.safe_string(trade['info'], 'status') == 'executed':
+                continue
             tradeSymbols[trade['symbol']] = True
             stored.append(trade)
         unique = list(tradeSymbols.keys())
+        uniqueLength = len(unique)
+        if uniqueLength == 0:
+            return
         for i in range(0, len(unique)):
             symbol = unique[i]
             symbolSpecificMessageHash = messageHash + ':' + symbol
@@ -310,20 +293,11 @@ class probit(ccxt.async_support.probit):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.authenticate(params)
-        url = self.urls['api']['ws']
         messageHash = 'orders'
         if symbol is not None:
-            market = self.market(symbol)
-            symbol = market['symbol']
+            symbol = self.safe_symbol(symbol)
             messageHash = messageHash + ':' + symbol
-        channel = None
-        channel, params = self.handle_option_and_params(params, 'watchOrders', 'channel', 'open_order')
-        subscribe: dict = {
-            'type': 'subscribe',
-            'channel': channel,
-        }
-        request = self.extend(subscribe, params)
-        orders = await self.watch(url, messageHash, request, channel)
+        orders = await self.subscribe_private(messageHash, 'open_order', params)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
@@ -388,39 +362,49 @@ class probit(ccxt.async_support.probit):
         :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
         """
-        filter = None
-        filter, params = self.handle_option_and_params(params, 'watchOrderBook', 'filter', 'order_books')
-        orderbook = await self.subscribe_order_book(symbol, 'orderbook', filter, params)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchOrderBook', 'filter', 'order_books')
+        orderbook = await self.subscribe_public('watchOrderBook', symbol, 'orderbook', channel, params)
         return orderbook.limit()
 
-    async def subscribe_order_book(self, symbol: str, messageHash, filter, params={}):
+    async def subscribe_private(self, messageHash, channel, params):
+        url = self.urls['api']['ws']
+        subscribe: dict = {
+            'type': 'subscribe',
+            'channel': channel,
+        }
+        request = self.extend(subscribe, params)
+        subscribeHash = messageHash
+        return await self.watch(url, messageHash, request, subscribeHash)
+
+    async def subscribe_public(self, methodName: str, symbol: str, dataType, filter, params={}):
         await self.load_markets()
         market = self.market(symbol)
         symbol = market['symbol']
         url = self.urls['api']['ws']
         client = self.client(url)
-        interval = None
-        interval, params = self.handle_option_and_params(params, 'watchOrderBook', 'interval', 100)
-        subscriptionHash = 'marketdata:' + symbol
-        messageHash = messageHash + ':' + symbol
+        subscribeHash = 'marketdata:' + symbol
+        messageHash = dataType + ':' + symbol
         filters = {}
-        if subscriptionHash in client.subscriptions:
+        if subscribeHash in client.subscriptions:
             # already subscribed
-            filters = client.subscriptions[subscriptionHash]
+            filters = client.subscriptions[subscribeHash]
             if not (filter in filters):
                 # resubscribe
-                del client.subscriptions[subscriptionHash]
+                del client.subscriptions[subscribeHash]
         filters[filter] = True
         keys = list(filters.keys())
-        message: dict = {
+        interval = None
+        interval, params = self.handle_option_and_params(params, methodName, 'interval', 100)
+        request: dict = {
+            'type': 'subscribe',
             'channel': 'marketdata',
-            'interval': interval,
             'market_id': market['id'],
-            'type': 'subscribe',
             'filter': keys,
+            'interval': interval,
         }
-        request = self.extend(message, params)
-        return await self.watch(url, messageHash, request, messageHash, filters)
+        request = self.extend(request, params)
+        return await self.watch(url, messageHash, request, subscribeHash, filters)
 
     def handle_order_book(self, client: Client, message, orderBook):
         #
@@ -493,7 +477,8 @@ class probit(ccxt.async_support.probit):
         result = self.safe_string(message, 'result')
         future = client.subscriptions['authenticated']
         if result == 'ok':
-            future.resolve(True)
+            messageHash = 'authenticated'
+            client.resolve(message, messageHash)
         else:
             future.reject(message)
             del client.subscriptions['authenticated']
@@ -521,6 +506,9 @@ class probit(ccxt.async_support.probit):
         #         }
         #     }
         #
+        # Note about 'reset' field
+        # 'reset': True field - it happens once after initial subscription, which just returns old items by the moment of subscription(like "fetchMyTrades" does)
+        #
         errorCode = self.safe_string(message, 'errorCode')
         if errorCode is not None:
             self.handle_error_message(client, message)

ccxt/test/tests_async.py

@@ -714,7 +714,7 @@ class testMainClass:
             result[key] = value
         return result
 
-    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+    def assert_new_and_stored_output_inner(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
         if is_null_value(new_output) and is_null_value(stored_output):
             return True
         if not new_output and not stored_output:
@@ -796,6 +796,25 @@ class testMainClass:
                         self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
         return True   # c# requ
 
+    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+        try:
+            return self.assert_new_and_stored_output_inner(exchange, skip_keys, new_output, stored_output, strict_type_check, asserting_key)
+        except Exception as e:
+            if self.info:
+                error_message = self.var_to_string(new_output) + '(calculated)' + ' != ' + self.var_to_string(stored_output) + '(stored)'
+                dump('[TEST_FAILURE_DETAIL]' + error_message)
+            raise e
+
+    def var_to_string(self, obj=None):
+        new_string = None
+        if obj is None:
+            new_string = 'undefined'
+        elif is_null_value(obj):
+            new_string = 'null'
+        else:
+            new_string = json_stringify(obj)
+        return new_string
+
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
             # remove the host part from the url
@@ -1064,7 +1083,15 @@ class testMainClass:
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
             else:
                 promises.append(self.test_exchange_response_statically(exchange_name, exchange_data, test_name))
-        await asyncio.gather(*promises)
+        try:
+            await asyncio.gather(*promises)
+        except Exception as e:
+            if type == 'request':
+                self.request_tests_failed = True
+            else:
+                self.response_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + '[' + exchange.id + ']' + str(e)
+            dump('[TEST_FAILURE]' + error_message)
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:

ccxt/test/tests_sync.py

@@ -711,7 +711,7 @@ class testMainClass:
             result[key] = value
         return result
 
-    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+    def assert_new_and_stored_output_inner(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
         if is_null_value(new_output) and is_null_value(stored_output):
             return True
         if not new_output and not stored_output:
@@ -793,6 +793,25 @@ class testMainClass:
                         self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
         return True   # c# requ
 
+    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+        try:
+            return self.assert_new_and_stored_output_inner(exchange, skip_keys, new_output, stored_output, strict_type_check, asserting_key)
+        except Exception as e:
+            if self.info:
+                error_message = self.var_to_string(new_output) + '(calculated)' + ' != ' + self.var_to_string(stored_output) + '(stored)'
+                dump('[TEST_FAILURE_DETAIL]' + error_message)
+            raise e
+
+    def var_to_string(self, obj=None):
+        new_string = None
+        if obj is None:
+            new_string = 'undefined'
+        elif is_null_value(obj):
+            new_string = 'null'
+        else:
+            new_string = json_stringify(obj)
+        return new_string
+
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
             # remove the host part from the url
@@ -1061,7 +1080,15 @@ class testMainClass:
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
             else:
                 promises.append(self.test_exchange_response_statically(exchange_name, exchange_data, test_name))
-        (promises)
+        try:
+            (promises)
+        except Exception as e:
+            if type == 'request':
+                self.request_tests_failed = True
+            else:
+                self.response_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + '[' + exchange.id + ']' + str(e)
+            dump('[TEST_FAILURE]' + error_message)
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:

ccxt/xt.py

@@ -156,16 +156,16 @@ class xt(Exchange, ImplicitAPI):
                     'spot': {
                         'get': {
                             'currencies': 1,
-                            'depth': 0.05,
-                            'kline': 0.1,
-                            'symbol': 1,  # 0.1 for a single symbol
-                            'ticker': 1,  # 0.1 for a single symbol
-                            'ticker/book': 1,  # 0.1 for a single symbol
-                            'ticker/price': 1,  # 0.1 for a single symbol
-                            'ticker/24h': 1,  # 0.1 for a single symbol
+                            'depth': 10,
+                            'kline': 1,
+                            'symbol': 1,  # 1 for a single symbol
+                            'ticker': 1,  # 1 for a single symbol
+                            'ticker/book': 1,  # 1 for a single symbol
+                            'ticker/price': 1,  # 1 for a single symbol
+                            'ticker/24h': 1,  # 1 for a single symbol
                             'time': 1,
-                            'trade/history': 0.1,
-                            'trade/recent': 0.1,
+                            'trade/history': 1,
+                            'trade/recent': 1,
                             'wallet/support/currency': 1,
                         },
                     },
@@ -235,7 +235,7 @@ class xt(Exchange, ImplicitAPI):
                         },
                         'post': {
                             'order': 0.2,
-                            'withdraw': 1,
+                            'withdraw': 10,
                             'balance/transfer': 1,
                             'balance/account/transfer': 1,
                             'ws-token': 1,

{ccxt-4.4.34.dist-info → ccxt-4.4.35.dist-info}/METADATA

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