ccxt 4.3.30__py2.py3-none-any.whl → 4.3.31__py2.py3-none-any.whl

ccxt/pro/binance.py

@@ -263,12 +263,12 @@ class binance(ccxt.async_support.binance):
         messageHashesLength = len(messageHashes)
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, streamHash, messageHashesLength)
         requestId = self.request_id(url)
-        request = {
+        request: dict = {
             'method': 'SUBSCRIBE',
             'params': subParams,
             'id': requestId,
         }
-        subscription = {
+        subscription: dict = {
             'id': str(requestId),
             'name': name,
             'symbols': symbols,
@@ -292,7 +292,7 @@ class binance(ccxt.async_support.binance):
         """
         await self.load_markets()
         market = self.market(symbol)
-        payload = {
+        payload: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -307,12 +307,12 @@ class binance(ccxt.async_support.binance):
         returnRateLimits, params = self.handle_option_and_params(params, 'createOrderWs', 'returnRateLimits', False)
         payload['returnRateLimits'] = returnRateLimits
         params = self.omit(params, 'test')
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'depth',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_fetch_order_book,
         }
         orderbook = await self.watch(url, messageHash, message, messageHash, subscription)
@@ -568,12 +568,12 @@ class binance(ccxt.async_support.binance):
         subParamsLength = len(subParams)
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, streamHash, subParamsLength)
         requestId = self.request_id(url)
-        request = {
+        request: dict = {
             'method': 'SUBSCRIBE',
             'params': subParams,
             'id': requestId,
         }
-        subscribe = {
+        subscribe: dict = {
             'id': requestId,
         }
         trades = await self.watch_multiple(url, subParams, self.extend(request, query), subParams, subscribe)
@@ -796,14 +796,14 @@ class binance(ccxt.async_support.binance):
             type = 'future' if market['linear'] else 'delivery'
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
         requestId = self.request_id(url)
-        request = {
+        request: dict = {
             'method': 'SUBSCRIBE',
             'params': [
                 messageHash,
             ],
             'id': requestId,
         }
-        subscribe = {
+        subscribe: dict = {
             'id': requestId,
         }
         ohlcv = await self.watch(url, messageHash, self.extend(request, params), messageHash, subscribe)
@@ -839,7 +839,7 @@ class binance(ccxt.async_support.binance):
         #     }
         #
         event = self.safe_string(message, 'e')
-        eventMap = {
+        eventMap: dict = {
             'indexPrice_kline': 'indexPriceKline',
             'markPrice_kline': 'markPriceKline',
         }
@@ -886,7 +886,7 @@ class binance(ccxt.async_support.binance):
         """
         await self.load_markets()
         market = self.market(symbol)
-        payload = {
+        payload: dict = {
             'symbol': market['id'],
         }
         type = self.get_market_type('fetchTickerWs', market, params)
@@ -895,7 +895,7 @@ class binance(ccxt.async_support.binance):
         url = self.urls['api']['ws']['ws-api'][type]
         requestId = self.request_id(url)
         messageHash = str(requestId)
-        subscription = {
+        subscription: dict = {
             'method': self.handle_ticker_ws,
         }
         returnRateLimits = False
@@ -904,7 +904,7 @@ class binance(ccxt.async_support.binance):
         params = self.omit(params, 'test')
         method = None
         method, params = self.handle_option_and_params(params, 'fetchTickerWs', 'method', 'ticker.book')
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': method,
             'params': self.sign_params(self.extend(payload, params)),
@@ -937,7 +937,7 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchOHLCVWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
             'interval': self.timeframes[timeframe],
@@ -950,12 +950,12 @@ class binance(ccxt.async_support.binance):
             payload['limit'] = limit
         if until is not None:
             payload['endTime'] = until
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'klines',
             'params': self.extend(payload, params),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_fetch_ohlcv,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -1084,12 +1084,12 @@ class binance(ccxt.async_support.binance):
             streamHash = channelName + '::' + ','.join(symbols)
         url = self.urls['api']['ws'][rawMarketType] + '/' + self.stream(rawMarketType, streamHash)
         requestId = self.request_id(url)
-        request = {
+        request: dict = {
             'method': 'SUBSCRIBE',
             'params': subscriptionArgs,
             'id': requestId,
         }
-        subscribe = {
+        subscribe: dict = {
             'id': requestId,
         }
         result = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), subscriptionArgs, subscribe)
@@ -1098,7 +1098,7 @@ class binance(ccxt.async_support.binance):
         if not symbolsDefined:
             return result
         else:
-            newDict = {}
+            newDict: dict = {}
             newDict[result['symbol']] = result
             return newDict
 
@@ -1283,7 +1283,7 @@ class binance(ccxt.async_support.binance):
         channelName = None
         resolvedMessageHashes = []
         rawTickers = []
-        newTickers = {}
+        newTickers: dict = {}
         if isinstance(message, list):
             rawTickers = message
         else:
@@ -1407,7 +1407,7 @@ class binance(ccxt.async_support.binance):
         if listenKey is None:
             # A network error happened: we can't renew a listen key that does not exist.
             return
-        request = {}
+        request: dict = {}
         symbol = self.safe_string(params, 'symbol')
         params = self.omit(params, ['type', 'symbol'])
         time = self.milliseconds()
@@ -1470,7 +1470,7 @@ class binance(ccxt.async_support.binance):
             self.balance[type] = {}
 
     async def load_balance_snapshot(self, client, messageHash, type, isPortfolioMargin):
-        params = {
+        params: dict = {
             'type': type,
         }
         if isPortfolioMargin:
@@ -1504,17 +1504,17 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchBalanceWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'returnRateLimits': returnRateLimits,
         }
         method = None
         method, params = self.handle_option_and_params(params, 'fetchBalanceWs', 'method', 'account.status')
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': method,
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_account_status_ws if (method == 'account.status') else self.handle_balance_ws,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -1604,7 +1604,7 @@ class binance(ccxt.async_support.binance):
         url = self.urls['api']['ws']['ws-api']['future']
         requestId = self.request_id(url)
         messageHash = str(requestId)
-        payload = {}
+        payload: dict = {}
         if symbols is not None:
             symbolsLength = len(symbols)
             if symbolsLength == 1:
@@ -1612,12 +1612,12 @@ class binance(ccxt.async_support.binance):
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchPositionsWs', 'returnRateLimits', False)
         payload['returnRateLimits'] = returnRateLimits
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'account.position',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_positions_ws,
         }
         result = await self.watch(url, messageHash, message, messageHash, subscription)
@@ -1840,7 +1840,7 @@ class binance(ccxt.async_support.binance):
         payload['returnRateLimits'] = returnRateLimits
         test = self.safe_bool(params, 'test', False)
         params = self.omit(params, 'test')
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'order.place',
             'params': self.sign_params(self.extend(payload, params)),
@@ -1850,7 +1850,7 @@ class binance(ccxt.async_support.binance):
                 message['method'] = 'sor.order.test'
             else:
                 message['method'] = 'order.test'
-        subscription = {
+        subscription: dict = {
             'method': self.handle_order_ws,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -1981,12 +1981,12 @@ class binance(ccxt.async_support.binance):
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'editOrderWs', 'returnRateLimits', False)
         payload['returnRateLimits'] = returnRateLimits
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'order.modify' if (marketType == 'future') else 'order.cancelReplace',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_edit_order_ws,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2121,7 +2121,7 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'cancelOrderWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
         }
@@ -2131,12 +2131,12 @@ class binance(ccxt.async_support.binance):
         else:
             payload['orderId'] = self.parse_to_int(id)
         params = self.omit(params, ['origClientOrderId', 'clientOrderId'])
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'order.cancel',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_order_ws,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2159,16 +2159,16 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'cancelAllOrdersWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
         }
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'order.cancel',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_orders_ws,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2194,7 +2194,7 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchOrderWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
         }
@@ -2203,12 +2203,12 @@ class binance(ccxt.async_support.binance):
             payload['origClientOrderId'] = clientOrderId
         else:
             payload['orderId'] = self.parse_to_int(id)
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'order.status',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_order_ws,
         }
         return await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2239,16 +2239,16 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchOrderWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
         }
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'allOrders',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_orders_ws,
         }
         orders = await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2292,17 +2292,17 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchOrderWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'returnRateLimits': returnRateLimits,
         }
         if symbol is not None:
             payload['symbol'] = self.market_id(symbol)
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'openOrders.status',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_orders_ws,
         }
         orders = await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2606,7 +2606,7 @@ class binance(ccxt.async_support.binance):
         if not self.is_empty(symbols):
             market = self.get_market_from_symbols(symbols)
             messageHash = '::' + ','.join(symbols)
-        marketTypeObject = {}
+        marketTypeObject: dict = {}
         if market is not None:
             marketTypeObject['type'] = market['type']
             marketTypeObject['subType'] = market['subType']
@@ -2659,7 +2659,7 @@ class binance(ccxt.async_support.binance):
             self.positions[type] = ArrayCacheBySymbolBySide()
 
     async def load_positions_snapshot(self, client, messageHash, type, isPortfolioMargin):
-        params = {
+        params: dict = {
             'type': type,
         }
         if isPortfolioMargin:
@@ -2811,7 +2811,7 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchMyTradesWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
         }
@@ -2822,12 +2822,12 @@ class binance(ccxt.async_support.binance):
         fromId = self.safe_integer(params, 'fromId')
         if fromId is not None and since is not None:
             raise BadRequest(self.id + 'fetchMyTradesWs does not support fetching by both fromId and since parameters at the same time')
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'myTrades',
             'params': self.sign_params(self.extend(payload, params)),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_trades_ws,
         }
         trades = await self.watch(url, messageHash, message, messageHash, subscription)
@@ -2858,18 +2858,18 @@ class binance(ccxt.async_support.binance):
         messageHash = str(requestId)
         returnRateLimits = False
         returnRateLimits, params = self.handle_option_and_params(params, 'fetchTradesWs', 'returnRateLimits', False)
-        payload = {
+        payload: dict = {
             'symbol': self.market_id(symbol),
             'returnRateLimits': returnRateLimits,
         }
         if limit is not None:
             payload['limit'] = limit
-        message = {
+        message: dict = {
             'id': messageHash,
             'method': 'trades.historical',
             'params': self.extend(payload, params),
         }
-        subscription = {
+        subscription: dict = {
             'method': self.handle_trades_ws,
         }
         trades = await self.watch(url, messageHash, message, messageHash, subscription)
@@ -3108,7 +3108,7 @@ class binance(ccxt.async_support.binance):
             method(client, message)
             return
         # handle other APIs
-        methods = {
+        methods: dict = {
             'depthUpdate': self.handle_order_book,
             'trade': self.handle_trade,
             'aggTrade': self.handle_trade,

ccxt/pro/bingx.py

@@ -95,7 +95,7 @@ class bingx(ccxt.async_support.bingx):
             raise BadRequest(self.id + ' watchTrades is not supported for ' + marketType + ' markets.')
         messageHash = market['id'] + '@ticker'
         uuid = self.uuid()
-        request = {
+        request: dict = {
             'id': uuid,
             'dataType': messageHash,
         }
@@ -193,7 +193,7 @@ class bingx(ccxt.async_support.bingx):
         #         "b": "2.5747"
         #     }
         #
-        timestamp = self.safe_integer(message, 'ts')
+        timestamp = self.safe_integer(message, 'C')
         marketId = self.safe_string(message, 's')
         market = self.safe_market(marketId, market)
         close = self.safe_string(message, 'c')
@@ -239,7 +239,7 @@ class bingx(ccxt.async_support.bingx):
             raise BadRequest(self.id + ' watchTrades is not supported for ' + marketType + ' markets.')
         messageHash = market['id'] + '@trade'
         uuid = self.uuid()
-        request = {
+        request: dict = {
             'id': uuid,
             'dataType': messageHash,
         }
@@ -358,7 +358,7 @@ class bingx(ccxt.async_support.bingx):
             raise BadRequest(self.id + ' watchOrderBook is not supported for ' + marketType + ' markets.')
         messageHash = market['id'] + '@depth' + str(limit)
         uuid = self.uuid()
-        request = {
+        request: dict = {
             'id': uuid,
             'dataType': messageHash,
         }
@@ -544,7 +544,7 @@ class bingx(ccxt.async_support.bingx):
         interval = self.safe_string(timeframes, timeframe, timeframe)
         messageHash = market['id'] + '@kline_' + interval
         uuid = self.uuid()
-        request = {
+        request: dict = {
             'id': uuid,
             'dataType': messageHash,
         }

ccxt/pro/bitfinex.py

@@ -51,7 +51,7 @@ class bitfinex(ccxt.async_support.bitfinex):
         url = self.urls['api']['ws']['public']
         messageHash = channel + ':' + marketId
         # channel = 'trades'
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'channel': channel,
             'symbol': marketId,
@@ -249,7 +249,7 @@ class bitfinex(ccxt.async_support.bitfinex):
         options = self.safe_value(self.options, 'watchOrderBook', {})
         prec = self.safe_string(options, 'prec', 'P0')
         freq = self.safe_string(options, 'freq', 'F0')
-        request = {
+        request: dict = {
             # "event": "subscribe",  # added in subscribe()
             # "channel": channel,  # added in subscribe()
             # "symbol": marketId,  # added in subscribe()
@@ -393,7 +393,7 @@ class bitfinex(ccxt.async_support.bitfinex):
             nonce = self.milliseconds()
             payload = 'AUTH' + str(nonce)
             signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha384, 'hex')
-            request = {
+            request: dict = {
                 'apiKey': self.apiKey,
                 'authSig': signature,
                 'authNonce': nonce,
@@ -504,7 +504,7 @@ class bitfinex(ccxt.async_support.bitfinex):
             client.resolve(self.orders, 'os')
 
     def parse_ws_order_status(self, status):
-        statuses = {
+        statuses: dict = {
             'ACTIVE': 'open',
             'CANCELED': 'canceled',
         }
@@ -586,7 +586,7 @@ class bitfinex(ccxt.async_support.bitfinex):
             subscription = self.safe_value(client.subscriptions, channelId, {})
             channel = self.safe_string(subscription, 'channel')
             name = self.safe_string(message, 1)
-            methods = {
+            methods: dict = {
                 'book': self.handle_order_book,
                 # 'ohlc': self.handleOHLCV,
                 'ticker': self.handle_ticker,
@@ -610,7 +610,7 @@ class bitfinex(ccxt.async_support.bitfinex):
             #
             event = self.safe_string(message, 'event')
             if event is not None:
-                methods = {
+                methods: dict = {
                     'info': self.handle_system_status,
                     # 'book': 'handleOrderBook',
                     'subscribed': self.handle_subscription_status,

ccxt/pro/bitfinex2.py

@@ -55,7 +55,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
         url = self.urls['api']['ws']['public']
         client = self.client(url)
         messageHash = channel + ':' + marketId
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'channel': channel,
             'symbol': marketId,
@@ -93,7 +93,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
         channel = 'candles'
         key = 'trade:' + interval + ':' + market['id']
         messageHash = channel + ':' + interval + ':' + market['id']
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'channel': channel,
             'key': key,
@@ -508,7 +508,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
         options = self.safe_value(self.options, 'watchOrderBook', {})
         prec = self.safe_string(options, 'prec', 'P0')
         freq = self.safe_string(options, 'freq', 'F0')
-        request = {
+        request: dict = {
             'prec': prec,  # string, level of price aggregation, 'P0', 'P1', 'P2', 'P3', 'P4', default P0
             'freq': freq,  # string, frequency of updates 'F0' = realtime, 'F1' = 2 seconds, default is 'F0'
         }
@@ -728,7 +728,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             data = self.safe_value(message, 2)
         else:
             data = [self.safe_value(message, 2)]
-        updatedTypes = {}
+        updatedTypes: dict = {}
         for i in range(0, len(data)):
             rawBalance = data[i]
             currencyId = self.safe_string(rawBalance, 1)
@@ -805,7 +805,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             payload = 'AUTH' + str(nonce)
             signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha384, 'hex')
             event = 'auth'
-            request = {
+            request: dict = {
                 'apiKey': self.apiKey,
                 'authSig': signature,
                 'authNonce': nonce,
@@ -896,7 +896,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)
         orders = self.orders
-        symbolIds = {}
+        symbolIds: dict = {}
         if messageType == 'os':
             snapshotLength = len(data)
             if snapshotLength == 0:
@@ -922,7 +922,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             client.resolve(self.orders, messageHash)
 
     def parse_ws_order_status(self, status):
-        statuses = {
+        statuses: dict = {
             'ACTIVE': 'open',
             'CANCELED': 'canceled',
             'EXECUTED': 'closed',
@@ -1047,14 +1047,14 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             subscription = self.safe_value(client.subscriptions, channelId, {})
             channel = self.safe_string(subscription, 'channel')
             name = self.safe_string(message, 1)
-            publicMethods = {
+            publicMethods: dict = {
                 'book': self.handle_order_book,
                 'cs': self.handle_checksum,
                 'candles': self.handle_ohlcv,
                 'ticker': self.handle_ticker,
                 'trades': self.handle_trades,
             }
-            privateMethods = {
+            privateMethods: dict = {
                 'os': self.handle_orders,
                 'ou': self.handle_orders,
                 'on': self.handle_orders,
@@ -1073,7 +1073,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
         else:
             event = self.safe_string(message, 'event')
             if event is not None:
-                methods = {
+                methods: dict = {
                     'info': self.handle_system_status,
                     'subscribed': self.handle_subscription_status,
                     'auth': self.handle_authentication_message,