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

ccxt/pro/hitbtc.py

@@ -92,7 +92,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         if authenticated is None:
             timestamp = self.milliseconds()
             signature = self.hmac(self.encode(self.number_to_string(timestamp)), self.encode(self.secret), hashlib.sha256, 'hex')
-            request = {
+            request: dict = {
                 'method': 'login',
                 'params': {
                     'type': 'HS256',
@@ -133,7 +133,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         messageHash = messageHashPrefix
         if symbols is not None:
             messageHash = messageHash + '::' + ','.join(symbols)
-        subscribe = {
+        subscribe: dict = {
             'method': 'subscribe',
             'id': self.nonce(),
             'ch': name,
@@ -155,7 +155,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         messageHash = self.safe_string(splitName, 0)
         if symbol is not None:
             messageHash = messageHash + '::' + symbol
-        subscribe = {
+        subscribe: dict = {
             'method': name,
             'params': params,
             'id': self.nonce(),
@@ -173,7 +173,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         await self.authenticate()
         url = self.urls['api']['ws']['private']
         messageHash = str(self.nonce())
-        subscribe = {
+        subscribe: dict = {
             'method': name,
             'params': params,
             'id': messageHash,
@@ -210,7 +210,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         elif name == 'orderbook/top/{speed}/batch':
             name = 'orderbook/top/' + speed + 'ms/batch'
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'params': {
                 'symbols': [market['id']],
             },
@@ -304,7 +304,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         name = self.implode_params(method, {'speed': speed})
         params = self.omit(params, ['method', 'speed'])
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'params': {
                 'symbols': [market['id']],
             },
@@ -335,7 +335,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             for i in range(0, len(symbols)):
                 marketId = self.market_id(symbols[i])
                 marketIds.append(marketId)
-        request = {
+        request: dict = {
             'params': {
                 'symbols': marketIds,
             },
@@ -386,7 +386,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         #
         data = self.safe_value(message, 'data', {})
         marketIds = list(data.keys())
-        newTickers = {}
+        newTickers: dict = {}
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
             market = self.safe_market(marketId)
@@ -475,7 +475,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'params': {
                 'symbols': [market['id']],
             },
@@ -597,7 +597,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         period = self.safe_string(self.timeframes, timeframe, timeframe)
         name = 'candles/' + period
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'params': {
                 'symbols': [market['id']],
             },
@@ -939,7 +939,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         })
         mode = self.safe_string(params, 'mode', 'batches')
         params = self.omit(params, 'mode')
-        request = {
+        request: dict = {
             'mode': mode,
         }
         return await self.subscribe_private(name, None, self.extend(request, params))
@@ -1052,7 +1052,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         """
         await self.load_markets()
         market = None
-        request = {}
+        request: dict = {}
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
@@ -1142,7 +1142,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         if channel is not None:
             splitChannel = channel.split('/')
             channel = self.safe_string(splitChannel, 0)
-            methods = {
+            methods: dict = {
                 'candles': self.handle_ohlcv,
                 'ticker': self.handle_ticker,
                 'trades': self.handle_trades,

ccxt/pro/hollaex.py

@@ -218,7 +218,7 @@ class hollaex(ccxt.async_support.hollaex):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCache(limit)
         stored = self.myTrades
-        marketIds = {}
+        marketIds: dict = {}
         for i in range(0, len(rawTrades)):
             trade = rawTrades[i]
             parsed = self.parse_trade(trade)
@@ -329,7 +329,7 @@ class hollaex(ccxt.async_support.hollaex):
             rawOrders = [data]
         else:
             rawOrders = data
-        marketIds = {}
+        marketIds: dict = {}
         for i in range(0, len(rawOrders)):
             order = rawOrders[i]
             parsed = self.parse_order(order)
@@ -394,7 +394,7 @@ class hollaex(ccxt.async_support.hollaex):
 
     async def watch_public(self, messageHash, params={}):
         url = self.urls['api']['ws']
-        request = {
+        request: dict = {
             'op': 'subscribe',
             'args': [messageHash],
         }
@@ -414,13 +414,13 @@ class hollaex(ccxt.async_support.hollaex):
         url = self.urls['api']['ws']
         auth = 'CONNECT' + '/stream' + expires
         signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
-        authParams = {
+        authParams: dict = {
             'api-key': self.apiKey,
             'api-signature': signature,
             'api-expires': expires,
         }
         signedUrl = url + '?' + self.urlencode(authParams)
-        request = {
+        request: dict = {
             'op': 'subscribe',
             'args': [messageHash],
         }
@@ -534,7 +534,7 @@ class hollaex(ccxt.async_support.hollaex):
         if content == 'pong':
             self.handle_pong(client, message)
             return
-        methods = {
+        methods: dict = {
             'trade': self.handle_trades,
             'orderbook': self.handle_order_book,
             'order': self.handle_order,

ccxt/pro/htx.py

@@ -432,13 +432,13 @@ class htx(ccxt.async_support.htx):
         market = self.market(symbol)
         url = self.get_url_by_market_type(market['type'], market['linear'], False, True)
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'req': messageHash,
             'id': requestId,
         }
         # self is a temporary subscription by a specific requestId
         # it has a very short lifetime until the snapshot is received over ws
-        snapshotSubscription = {
+        snapshotSubscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'symbol': symbol,
@@ -886,7 +886,7 @@ class htx(ccxt.async_support.htx):
                 status = self.parse_order_status(self.safe_string_2(data, 'orderStatus', 'status', 'closed'))
                 filled = self.safe_string(data, 'execAmt')
                 remaining = self.safe_string(data, 'remainAmt')
-                order = {
+                order: dict = {
                     'id': orderId,
                     'trades': trades,
                     'status': status,
@@ -903,13 +903,13 @@ class htx(ccxt.async_support.htx):
             rawTrades = self.safe_value(message, 'trade', [])
             tradesLength = len(rawTrades)
             if tradesLength > 0:
-                tradesObject = {
+                tradesObject: dict = {
                     'trades': rawTrades,
                     'ch': messageHash,
                     'symbol': marketId,
                 }
                 # inject order params in every trade
-                extendTradeParams = {
+                extendTradeParams: dict = {
                     'order': self.safe_string(parsedOrder, 'id'),
                     'type': self.safe_string(parsedOrder, 'type'),
                     'side': self.safe_string(parsedOrder, 'side'),
@@ -1334,7 +1334,7 @@ class htx(ccxt.async_support.htx):
                 else:
                     # subscribe to all
                     channel = prefix + '.' + '*'
-        subscriptionParams = {
+        subscriptionParams: dict = {
             'type': type,
             'subType': subType,
             'margin': marginMode,
@@ -1541,7 +1541,7 @@ class htx(ccxt.async_support.htx):
                                 account = self.account()
                                 account['free'] = self.safe_string_2(balance, 'margin_balance', 'margin_available')
                                 account['used'] = self.safe_string(balance, 'margin_frozen')
-                                accountsByCode = {}
+                                accountsByCode: dict = {}
                                 accountsByCode[code] = account
                                 symbol = market['symbol']
                                 self.balance[symbol] = self.safe_balance(accountsByCode)
@@ -1687,7 +1687,7 @@ class htx(ccxt.async_support.htx):
         type = self.safe_string(parts, 0)
         if type == 'market':
             methodName = self.safe_string(parts, 2)
-            methods = {
+            methods: dict = {
                 'depth': self.handle_order_book,
                 'mbp': self.handle_order_book,
                 'detail': self.handle_ticker,
@@ -2083,7 +2083,7 @@ class htx(ccxt.async_support.htx):
 
     def get_url_by_market_type(self, type, isLinear=True, isPrivate=False, isFeed=False):
         api = self.safe_string(self.options, 'api', 'api')
-        hostname = {'hostname': self.hostname}
+        hostname: dict = {'hostname': self.hostname}
         hostnameURL = None
         url = None
         if type == 'spot':
@@ -2103,11 +2103,11 @@ class htx(ccxt.async_support.htx):
 
     async def subscribe_public(self, url, symbol, messageHash, method=None, params={}):
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'sub': messageHash,
             'id': requestId,
         }
-        subscription = {
+        subscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'symbol': symbol,
@@ -2119,7 +2119,7 @@ class htx(ccxt.async_support.htx):
 
     async def subscribe_private(self, channel, messageHash, type, subtype, params={}, subscriptionParams={}):
         requestId = self.request_id()
-        subscription = {
+        subscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'params': params,
@@ -2140,7 +2140,7 @@ class htx(ccxt.async_support.htx):
         isLinear = subtype == 'linear'
         url = self.get_url_by_market_type(type, isLinear, True)
         hostname = self.urls['hostnames']['spot'] if (type == 'spot') else self.urls['hostnames']['contract']
-        authParams = {
+        authParams: dict = {
             'type': type,
             'url': url,
             'hostname': hostname,
@@ -2183,7 +2183,7 @@ class htx(ccxt.async_support.htx):
             signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha256, 'base64')
             request = None
             if type == 'spot':
-                newParams = {
+                newParams: dict = {
                     'authType': 'api',
                     'accessKey': self.apiKey,
                     'signatureMethod': 'HmacSHA256',
@@ -2207,7 +2207,7 @@ class htx(ccxt.async_support.htx):
                     'Signature': signature,
                 }
             requestId = self.request_id()
-            subscription = {
+            subscription: dict = {
                 'id': requestId,
                 'messageHash': messageHash,
                 'params': params,

ccxt/pro/huobijp.py

@@ -62,14 +62,14 @@ class huobijp(ccxt.async_support.huobijp):
         # only supports a limit of 150 at self time
         messageHash = 'market.' + market['id'] + '.detail'
         api = self.safe_string(self.options, 'api', 'api')
-        hostname = {'hostname': self.hostname}
+        hostname: dict = {'hostname': self.hostname}
         url = self.implode_params(self.urls['api']['ws'][api]['public'], hostname)
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'sub': messageHash,
             'id': requestId,
         }
-        subscription = {
+        subscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'symbol': symbol,
@@ -124,14 +124,14 @@ class huobijp(ccxt.async_support.huobijp):
         # only supports a limit of 150 at self time
         messageHash = 'market.' + market['id'] + '.trade.detail'
         api = self.safe_string(self.options, 'api', 'api')
-        hostname = {'hostname': self.hostname}
+        hostname: dict = {'hostname': self.hostname}
         url = self.implode_params(self.urls['api']['ws'][api]['public'], hostname)
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'sub': messageHash,
             'id': requestId,
         }
-        subscription = {
+        subscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'symbol': symbol,
@@ -197,14 +197,14 @@ class huobijp(ccxt.async_support.huobijp):
         interval = self.safe_string(self.timeframes, timeframe, timeframe)
         messageHash = 'market.' + market['id'] + '.kline.' + interval
         api = self.safe_string(self.options, 'api', 'api')
-        hostname = {'hostname': self.hostname}
+        hostname: dict = {'hostname': self.hostname}
         url = self.implode_params(self.urls['api']['ws'][api]['public'], hostname)
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'sub': messageHash,
             'id': requestId,
         }
-        subscription = {
+        subscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'symbol': symbol,
@@ -268,14 +268,14 @@ class huobijp(ccxt.async_support.huobijp):
         limit = 150 if (limit is None) else limit
         messageHash = 'market.' + market['id'] + '.mbp.' + str(limit)
         api = self.safe_string(self.options, 'api', 'api')
-        hostname = {'hostname': self.hostname}
+        hostname: dict = {'hostname': self.hostname}
         url = self.implode_params(self.urls['api']['ws'][api]['public'], hostname)
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'sub': messageHash,
             'id': requestId,
         }
-        subscription = {
+        subscription: dict = {
             'id': requestId,
             'messageHash': messageHash,
             'symbol': symbol,
@@ -328,16 +328,16 @@ class huobijp(ccxt.async_support.huobijp):
             limit = self.safe_integer(subscription, 'limit')
             params = self.safe_value(subscription, 'params')
             api = self.safe_string(self.options, 'api', 'api')
-            hostname = {'hostname': self.hostname}
+            hostname: dict = {'hostname': self.hostname}
             url = self.implode_params(self.urls['api']['ws'][api]['public'], hostname)
             requestId = self.request_id()
-            request = {
+            request: dict = {
                 'req': messageHash,
                 'id': requestId,
             }
             # self is a temporary subscription by a specific requestId
             # it has a very short lifetime until the snapshot is received over ws
-            snapshotSubscription = {
+            snapshotSubscription: dict = {
                 'id': requestId,
                 'messageHash': messageHash,
                 'symbol': symbol,
@@ -500,7 +500,7 @@ class huobijp(ccxt.async_support.huobijp):
         type = self.safe_string(parts, 0)
         if type == 'market':
             methodName = self.safe_string(parts, 2)
-            methods = {
+            methods: dict = {
                 'mbp': self.handle_order_book,
                 'detail': self.handle_ticker,
                 'trade': self.handle_trades,

ccxt/pro/hyperliquid.py

@@ -66,7 +66,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         symbol = market['symbol']
         messageHash = 'orderbook:' + symbol
         url = self.urls['api']['ws']['public']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscription': {
                 'type': 'l2Book',
@@ -109,7 +109,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         market = self.market(marketId)
         symbol = market['symbol']
         rawData = self.safe_list(entry, 'levels', [])
-        data = {
+        data: dict = {
             'bids': self.safe_list(rawData, 0, []),
             'asks': self.safe_list(rawData, 1, []),
         }
@@ -141,7 +141,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             symbol = self.symbol(symbol)
             messageHash += ':' + symbol
         url = self.urls['api']['ws']['public']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscription': {
                 'type': 'userFills',
@@ -188,7 +188,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCacheBySymbolById(limit)
         trades = self.myTrades
-        symbols = {}
+        symbols: dict = {}
         data = self.safe_list(entry, 'fills', [])
         dataLength = len(data)
         if dataLength == 0:
@@ -221,7 +221,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         symbol = market['symbol']
         messageHash = 'trade:' + symbol
         url = self.urls['api']['ws']['public']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscription': {
                 'type': 'trades',
@@ -345,7 +345,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         market = self.market(symbol)
         symbol = market['symbol']
         url = self.urls['api']['ws']['public']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscription': {
                 'type': 'candle',
@@ -415,7 +415,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             symbol = market['symbol']
             messageHash = messageHash + ':' + symbol
         url = self.urls['api']['ws']['public']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscription': {
                 'type': 'orderUpdates',
@@ -458,7 +458,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             return
         stored = self.orders
         messageHash = 'order'
-        marketSymbols = {}
+        marketSymbols: dict = {}
         for i in range(0, len(data)):
             rawOrder = data[i]
             order = self.parse_order(rawOrder)
@@ -490,7 +490,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         if self.handle_error_message(client, message):
             return
         topic = self.safe_string(message, 'channel', '')
-        methods = {
+        methods: dict = {
             'pong': self.handle_pong,
             'trades': self.handle_trades,
             'l2Book': self.handle_order_book,

ccxt/pro/idex.py

@@ -49,7 +49,7 @@ class idex(ccxt.async_support.idex):
 
     async def subscribe(self, subscribeObject, messageHash, subscription=True):
         url = self.urls['test']['ws']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscriptions': [
                 subscribeObject,
@@ -60,7 +60,7 @@ class idex(ccxt.async_support.idex):
     async def subscribe_private(self, subscribeObject, messageHash):
         token = await self.authenticate()
         url = self.urls['test']['ws']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'token': token,
             'subscriptions': [
@@ -79,7 +79,7 @@ class idex(ccxt.async_support.idex):
         await self.load_markets()
         market = self.market(symbol)
         name = 'tickers'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
         }
@@ -151,7 +151,7 @@ class idex(ccxt.async_support.idex):
         market = self.market(symbol)
         symbol = market['symbol']
         name = 'trades'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
         }
@@ -243,7 +243,7 @@ class idex(ccxt.async_support.idex):
         symbol = market['symbol']
         name = 'candles'
         interval = self.safe_string(self.timeframes, timeframe, timeframe)
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
             'interval': interval,
@@ -391,12 +391,12 @@ class idex(ccxt.async_support.idex):
         await self.load_markets()
         market = self.market(symbol)
         name = 'l2orderbook'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
         }
         messageHash = name + ':' + market['id']
-        subscription = {
+        subscription: dict = {
             'fetchingOrderBookSnapshot': False,
             'numAttempts': 0,
             'startTime': None,
@@ -466,7 +466,7 @@ class idex(ccxt.async_support.idex):
         time = self.seconds()
         lastAuthenticatedTime = self.safe_integer(self.options, 'lastAuthenticatedTime', 0)
         if time - lastAuthenticatedTime > 900:
-            request = {
+            request: dict = {
                 'wallet': self.walletAddress,
                 'nonce': self.uuidv1(),
             }
@@ -486,7 +486,7 @@ class idex(ccxt.async_support.idex):
         """
         await self.load_markets()
         name = 'orders'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
         }
         messageHash = name
@@ -602,7 +602,7 @@ class idex(ccxt.async_support.idex):
     async def watch_transactions(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         await self.load_markets()
         name = 'balances'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
         }
         messageHash = name
@@ -629,7 +629,7 @@ class idex(ccxt.async_support.idex):
         messageHash = type + ':' + currencyId
         code = self.safe_currency_code(currencyId)
         address = self.safe_string(data, 'w')
-        transaction = {
+        transaction: dict = {
             'info': message,
             'id': None,
             'currency': code,
@@ -658,7 +658,7 @@ class idex(ccxt.async_support.idex):
 
     def handle_message(self, client: Client, message):
         type = self.safe_string(message, 'type')
-        methods = {
+        methods: dict = {
             'tickers': self.handle_ticker,
             'trades': self.handle_trade,
             'subscriptions': self.handle_subscribe_message,

ccxt/pro/independentreserve.py

@@ -138,7 +138,7 @@ class independentreserve(ccxt.async_support.independentreserve):
         limitString = self.number_to_string(limit)
         url = self.urls['api']['ws'] + '/orderbook/' + limitString + '?subscribe=' + market['base'] + '-' + market['quote']
         messageHash = 'orderbook:' + symbol + ':' + limitString
-        subscription = {
+        subscription: dict = {
             'receivedSnapshot': False,
         }
         orderbook = await self.watch(url, messageHash, None, messageHash, subscription)
@@ -256,7 +256,7 @@ class independentreserve(ccxt.async_support.independentreserve):
 
     def handle_message(self, client: Client, message):
         event = self.safe_string(message, 'Event')
-        handlers = {
+        handlers: dict = {
             'Subscriptions': self.handle_subscriptions,
             'Heartbeat': self.handle_heartbeat,
             'Trade': self.handle_trades,