ccxt 4.2.30__py2.py3-none-any.whl → 4.2.34__py2.py3-none-any.whl

ccxt/pro/poloniex.py

@@ -974,13 +974,15 @@ class poloniex(ccxt.async_support.poloniex):
                         bid = self.safe_value(bids, j)
                         price = self.safe_number(bid, 0)
                         amount = self.safe_number(bid, 1)
-                        orderbook['bids'].store(price, amount)
+                        bidsSide = orderbook['bids']
+                        bidsSide.store(price, amount)
                 if asks is not None:
                     for j in range(0, len(asks)):
                         ask = self.safe_value(asks, j)
                         price = self.safe_number(ask, 0)
                         amount = self.safe_number(ask, 1)
-                        orderbook['asks'].store(price, amount)
+                        asksSide = orderbook['asks']
+                        asksSide.store(price, amount)
                 orderbook['symbol'] = symbol
                 orderbook['timestamp'] = timestamp
                 orderbook['datetime'] = self.iso8601(timestamp)
@@ -1104,12 +1106,12 @@ class poloniex(ccxt.async_support.poloniex):
             if orderId == '0':
                 self.handle_error_message(client, item)
             else:
-                return self.handle_order_request(client, message)
+                self.handle_order_request(client, message)
         else:
             data = self.safe_value(message, 'data', [])
             dataLength = len(data)
             if dataLength > 0:
-                return method(client, message)
+                method(client, message)
 
     def handle_error_message(self, client: Client, message):
         #

ccxt/pro/poloniexfutures.py

@@ -68,17 +68,20 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
             },
         })
 
-    def negotiate(self, privateChannel, params={}):
+    async def negotiate(self, privateChannel, params={}):
         connectId = 'private' if privateChannel else 'public'
         urls = self.safe_value(self.options, 'urls', {})
         if connectId in urls:
-            return urls[connectId]
+            # return urls[connectId]
+            storedFuture = urls[connectId]
+            return await storedFuture
         # we store an awaitable to the url
         # so that multiple calls don't asynchronously
         # fetch different urls and overwrite each other
         urls[connectId] = self.spawn(self.negotiate_helper, privateChannel, params)
         self.options['urls'] = urls
-        return urls[connectId]
+        future = urls[connectId]
+        return await future
 
     async def negotiate_helper(self, privateChannel, params={}):
         response = None
@@ -685,7 +688,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         messageHash = self.safe_string(message, 'topic')
         subject = self.safe_string(message, 'subject')
         if subject == 'received':
-            return message
+            return
         # At the time of writting self, there is no implementation to easily convert each order into the orderbook so raw messages are returned
         client.resolve(message, messageHash)
 
@@ -703,8 +706,9 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         topic = self.safe_string(message, 'topic')
         isSnapshot = topic.find('Depth') >= 0
         if isSnapshot:
-            return self.hande_l2_snapshot(client, message)
-        return self.handle_l2_order_book(client, message)
+            self.hande_l2_snapshot(client, message)
+            return
+        self.handle_l2_order_book(client, message)
 
     def handle_l2_order_book(self, client: Client, message):
         #
@@ -740,7 +744,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
             snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 5)
             if cacheLength == snapshotDelay:
                 limit = 0
-                self.spawn(self.load_order_book, client, messageHash, symbol, limit)
+                self.spawn(self.load_order_book, client, messageHash, symbol, limit, {})
             orderBook.cache.append(data)
             return
         try:
@@ -920,7 +924,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         }
         method = self.safe_value(methods, subject)
         if method is not None:
-            return method(client, message)
+            method(client, message)
 
     def ping(self, client: Client):
         id = str(self.request_id())
@@ -955,7 +959,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         }
         method = self.safe_value(methods, type)
         if method is not None:
-            return method(client, message)
+            method(client, message)
 
     def handle_authenticate(self, client, message):
         #

ccxt/pro/probit.py

@@ -428,17 +428,17 @@ class probit(ccxt.async_support.probit):
         symbol = self.safe_symbol(marketId)
         dataBySide = self.group_by(orderBook, 'side')
         messageHash = 'orderbook:' + symbol
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book({})
+            self.orderbooks[symbol] = orderbook
         reset = self.safe_bool(message, 'reset', False)
         if reset:
             snapshot = self.parse_order_book(dataBySide, symbol, None, 'buy', 'sell', 'price', 'quantity')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         else:
-            self.handle_delta(storedOrderBook, dataBySide)
-        client.resolve(storedOrderBook, messageHash)
+            self.handle_delta(orderbook, dataBySide)
+        client.resolve(orderbook, messageHash)
 
     def handle_bid_asks(self, bookSide, bidAsks):
         for i in range(0, len(bidAsks)):
@@ -505,10 +505,12 @@ class probit(ccxt.async_support.probit):
         #
         errorCode = self.safe_string(message, 'errorCode')
         if errorCode is not None:
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
+            return
         type = self.safe_string(message, 'type')
         if type == 'authorization':
-            return self.handle_authenticate(client, message)
+            self.handle_authenticate(client, message)
+            return
         handlers = {
             'marketdata': self.handle_market_data,
             'balance': self.handle_balance,
@@ -519,7 +521,8 @@ class probit(ccxt.async_support.probit):
         channel = self.safe_string(message, 'channel')
         handler = self.safe_value(handlers, channel)
         if handler is not None:
-            return handler(client, message)
+            handler(client, message)
+            return
         error = NotSupported(self.id + ' handleMessage: unknown message: ' + self.json(message))
         client.reject(error)
 
@@ -530,7 +533,7 @@ class probit(ccxt.async_support.probit):
         expires = self.safe_integer(self.options, 'expires', 0)
         future = self.safe_value(client.subscriptions, messageHash)
         if (future is None) or (self.milliseconds() > expires):
-            response = await self.signIn()
+            response = await self.sign_in()
             #
             #     {
             #         "access_token": "0ttDv/2hTTn3bLi8GP1gKaneiEQ6+0hOBenPrxNQt2s=",
@@ -545,4 +548,4 @@ class probit(ccxt.async_support.probit):
             }
             future = self.watch(url, messageHash, self.extend(request, params))
             client.subscriptions[messageHash] = future
-        return await future
+        return future

ccxt/pro/upbit.py

@@ -161,15 +161,15 @@ class upbit(ccxt.async_support.upbit):
         limit = self.safe_integer(options, 'limit', 15)
         if type == 'SNAPSHOT':
             self.orderbooks[symbol] = self.order_book({}, limit)
-        orderBook = self.orderbooks[symbol]
+        orderbook = self.orderbooks[symbol]
         # upbit always returns a snapshot of 15 topmost entries
         # the "REALTIME" deltas are not incremental
         # therefore we reset the orderbook on each update
         # and reinitialize it again with new bidasks
-        orderBook.reset({})
-        orderBook['symbol'] = symbol
-        bids = orderBook['bids']
-        asks = orderBook['asks']
+        orderbook.reset({})
+        orderbook['symbol'] = symbol
+        bids = orderbook['bids']
+        asks = orderbook['asks']
         data = self.safe_value(message, 'orderbook_units', [])
         for i in range(0, len(data)):
             entry = data[i]
@@ -181,10 +181,10 @@ class upbit(ccxt.async_support.upbit):
             bids.store(bid_price, bid_size)
         timestamp = self.safe_integer(message, 'timestamp')
         datetime = self.iso8601(timestamp)
-        orderBook['timestamp'] = timestamp
-        orderBook['datetime'] = datetime
+        orderbook['timestamp'] = timestamp
+        orderbook['datetime'] = datetime
         messageHash = 'orderbook:' + marketId
-        client.resolve(orderBook, messageHash)
+        client.resolve(orderbook, messageHash)
 
     def handle_trades(self, client: Client, message):
         # {type: "trade",

ccxt/pro/wazirx.py

@@ -698,7 +698,8 @@ class wazirx(ccxt.async_support.wazirx):
     def handle_message(self, client: Client, message):
         status = self.safe_string(message, 'status')
         if status == 'error':
-            return self.handle_error(client, message)
+            self.handle_error(client, message)
+            return
         event = self.safe_string(message, 'event')
         eventHandlers = {
             'error': self.handle_error,
@@ -707,7 +708,8 @@ class wazirx(ccxt.async_support.wazirx):
         }
         eventHandler = self.safe_value(eventHandlers, event)
         if eventHandler is not None:
-            return eventHandler(client, message)
+            eventHandler(client, message)
+            return
         stream = self.safe_string(message, 'stream', '')
         streamHandlers = {
             'ticker@arr': self.handle_ticker,
@@ -722,7 +724,8 @@ class wazirx(ccxt.async_support.wazirx):
         for i in range(0, len(streams)):
             if self.in_array(streams[i], stream):
                 handler = streamHandlers[streams[i]]
-                return handler(client, message)
+                handler(client, message)
+                return
         raise NotSupported(self.id + ' self message type is not supported yet. Message: ' + self.json(message))
 
     async def authenticate(self, params={}):

ccxt/pro/woo.py

@@ -407,7 +407,7 @@ class woo(ccxt.async_support.woo):
                 return False
         return True
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         self.check_required_credentials()
         url = self.urls['api']['ws']['private'] + '/' + self.uid
         client = self.client(url)
@@ -786,28 +786,30 @@ class woo(ccxt.async_support.woo):
         event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)
         if method is not None:
-            return method(client, message)
+            method(client, message)
+            return
         topic = self.safe_string(message, 'topic')
         if topic is not None:
             method = self.safe_value(methods, topic)
             if method is not None:
-                return method(client, message)
+                method(client, message)
+                return
             splitTopic = topic.split('@')
             splitLength = len(splitTopic)
             if splitLength == 2:
                 name = self.safe_string(splitTopic, 1)
                 method = self.safe_value(methods, name)
                 if method is not None:
-                    return method(client, message)
+                    method(client, message)
+                    return
                 splitName = name.split('_')
                 splitNameLength = len(splitTopic)
                 if splitNameLength == 2:
                     method = self.safe_value(methods, self.safe_string(splitName, 0))
                     if method is not None:
-                        return method(client, message)
-        return message
+                        method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {'event': 'ping'}
 
     def handle_ping(self, client: Client, message):

ccxt/probit.py

@@ -433,8 +433,8 @@ class probit(Exchange, ImplicitAPI):
             networkList = {}
             for j in range(0, len(platformsByPriority)):
                 network = platformsByPriority[j]
-                networkId = self.safe_string(network, 'id')
-                networkCode = self.network_id_to_code(networkId)
+                idInner = self.safe_string(network, 'id')
+                networkCode = self.network_id_to_code(idInner)
                 currentDepositSuspended = self.safe_value(network, 'deposit_suspended')
                 currentWithdrawalSuspended = self.safe_value(network, 'withdrawal_suspended')
                 currentDeposit = not currentDepositSuspended
@@ -452,7 +452,7 @@ class probit(Exchange, ImplicitAPI):
                         networkFee = withdrawPlatform
                         break
                 networkList[networkCode] = {
-                    'id': networkId,
+                    'id': idInner,
                     'network': networkCode,
                     'active': currentActive,
                     'deposit': currentDeposit,
@@ -1138,7 +1138,7 @@ class probit(Exchange, ImplicitAPI):
     def cost_to_precision(self, symbol, cost):
         return self.decimal_to_precision(cost, TRUNCATE, self.markets[symbol]['precision']['cost'], self.precisionMode)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://docs-en.probit.com/reference/order-1
@@ -1331,7 +1331,7 @@ class probit(Exchange, ImplicitAPI):
         data = self.safe_value(response, 'data', [])
         return self.parse_deposit_addresses(data, codes)
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         :see: https://docs-en.probit.com/reference/withdrawal
         make a withdrawal

ccxt/test/base/test_order_book.py

@@ -15,7 +15,7 @@ sys.path.append(root)
 from ccxt.base.precise import Precise  # noqa E402
 from ccxt.test.base import test_shared_methods  # noqa E402
 
-def test_order_book(exchange, skipped_properties, method, entry, symbol):
+def test_order_book(exchange, skipped_properties, method, orderbook, symbol):
     format = {
         'symbol': 'ETH/BTC',
         'asks': [[exchange.parse_number('1.24'), exchange.parse_number('0.453')], [exchange.parse_number('1.25'), exchange.parse_number('0.157')]],
@@ -25,14 +25,14 @@ def test_order_book(exchange, skipped_properties, method, entry, symbol):
         'nonce': 134234234,
     }
     empty_allowed_for = ['symbol', 'nonce', 'datetime', 'timestamp']  # todo: make timestamp required
-    test_shared_methods.assert_structure(exchange, skipped_properties, method, entry, format, empty_allowed_for)
-    test_shared_methods.assert_timestamp_and_datetime(exchange, skipped_properties, method, entry)
-    test_shared_methods.assert_symbol(exchange, skipped_properties, method, entry, 'symbol', symbol)
-    log_text = test_shared_methods.log_template(exchange, method, entry)
+    test_shared_methods.assert_structure(exchange, skipped_properties, method, orderbook, format, empty_allowed_for)
+    test_shared_methods.assert_timestamp_and_datetime(exchange, skipped_properties, method, orderbook)
+    test_shared_methods.assert_symbol(exchange, skipped_properties, method, orderbook, 'symbol', symbol)
+    log_text = test_shared_methods.log_template(exchange, method, orderbook)
     #
     if ('bid' in skipped_properties) or ('ask' in skipped_properties):
         return
-    bids = entry['bids']
+    bids = orderbook['bids']
     bids_length = len(bids)
     for i in range(0, bids_length):
         current_bid_string = exchange.safe_string(bids[i], 0)
@@ -43,7 +43,7 @@ def test_order_book(exchange, skipped_properties, method, entry, symbol):
             assert has_correct_order, 'current bid should be > than the next one: ' + current_bid_string + '>' + next_bid_string + log_text
         test_shared_methods.assert_greater(exchange, skipped_properties, method, bids[i], 0, '0')
         test_shared_methods.assert_greater(exchange, skipped_properties, method, bids[i], 1, '0')
-    asks = entry['asks']
+    asks = orderbook['asks']
     asks_length = len(asks)
     for i in range(0, asks_length):
         current_ask_string = exchange.safe_string(asks[i], 0)

ccxt/test/base/test_shared_methods.py

@@ -40,7 +40,7 @@ def string_value(value):
 
 def assert_type(exchange, skipped_properties, entry, key, format):
     if key in skipped_properties:
-        return
+        return None
     # because "typeof" string is not transpilable without === 'name', we list them manually at this moment
     entry_key_val = exchange.safe_value(entry, key)
     format_key_val = exchange.safe_value(format, key)