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

ccxt/async_support/ascendex.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.ascendex import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Balances, Currencies, Currency, Int, Leverage, Leverages, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Account, Balances, Currencies, Currency, Int, Leverage, Leverages, LeverageTier, LeverageTiers, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -465,7 +465,7 @@ class ascendex(Exchange, ImplicitAPI):
         cashById = self.index_by(cashData, 'assetCode')
         dataById = self.deep_extend(assetsById, marginById, cashById)
         ids = list(dataById.keys())
-        result = {}
+        result: dict = {}
         for i in range(0, len(ids)):
             id = ids[i]
             currency = dataById[id]
@@ -699,7 +699,7 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns int: the current integer timestamp in milliseconds from the ascendex server
         """
-        request = {
+        request: dict = {
             'requestTime': self.milliseconds(),
         }
         response = await self.v1PublicGetExchangeInfo(self.extend(request, params))
@@ -755,7 +755,7 @@ class ascendex(Exchange, ImplicitAPI):
         ]
 
     def parse_balance(self, response) -> Balances:
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': None,
             'datetime': None,
@@ -771,7 +771,7 @@ class ascendex(Exchange, ImplicitAPI):
         return self.safe_balance(result)
 
     def parse_margin_balance(self, response):
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': None,
             'datetime': None,
@@ -790,7 +790,7 @@ class ascendex(Exchange, ImplicitAPI):
         return self.safe_balance(result)
 
     def parse_swap_balance(self, response):
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': None,
             'datetime': None,
@@ -830,7 +830,7 @@ class ascendex(Exchange, ImplicitAPI):
         accountCategory = self.safe_string(accountsByType, marketType, 'cash')
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
         }
         if (marginMode == 'isolated') and (marketType != 'swap'):
@@ -904,7 +904,7 @@ class ascendex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = await self.v1PublicGetDepth(self.extend(request, params))
@@ -993,7 +993,7 @@ class ascendex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = await self.v1PublicGetTicker(self.extend(request, params))
@@ -1026,7 +1026,7 @@ class ascendex(Exchange, ImplicitAPI):
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         market = None
         if symbols is not None:
             symbol = self.safe_value(symbols, 0)
@@ -1101,7 +1101,7 @@ class ascendex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'interval': self.safe_string(self.timeframes, timeframe, timeframe),
         }
@@ -1143,7 +1143,7 @@ class ascendex(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_ohlcvs(data, market, timeframe, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # public fetchTrades
         #
@@ -1189,7 +1189,7 @@ class ascendex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -1213,8 +1213,8 @@ class ascendex(Exchange, ImplicitAPI):
         trades = self.safe_list(records, 'data', [])
         return self.parse_trades(trades, market, since, limit)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'PendingNew': 'open',
             'New': 'open',
             'PartiallyFilled': 'open',
@@ -1224,7 +1224,7 @@ class ascendex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # createOrder
         #
@@ -1406,7 +1406,7 @@ class ascendex(Exchange, ImplicitAPI):
         await self.load_accounts()
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
         }
         response = await self.v1PrivateAccountGroupGetSpotFee(self.extend(request, params))
@@ -1428,7 +1428,7 @@ class ascendex(Exchange, ImplicitAPI):
         #
         data = self.safe_value(response, 'data', {})
         fees = self.safe_value(data, 'fees', [])
-        result = {}
+        result: dict = {}
         for i in range(0, len(fees)):
             fee = fees[i]
             marketId = self.safe_string(fee, 'symbol')
@@ -1471,7 +1471,7 @@ class ascendex(Exchange, ImplicitAPI):
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_value(account, 'id')
         clientOrderId = self.safe_string_2(params, 'clientOrderId', 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'account-category': accountCategory,
             'symbol': market['id'],
@@ -1659,7 +1659,7 @@ class ascendex(Exchange, ImplicitAPI):
             accountCategory = 'margin'
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_value(account, 'id')
-        request = {}
+        request: dict = {}
         response = None
         if market['swap']:
             raise NotSupported(self.id + ' createOrders() is not currently supported for swap markets on ascendex')
@@ -1717,7 +1717,7 @@ class ascendex(Exchange, ImplicitAPI):
         accountCategory = self.safe_string(accountsByType, type, 'cash')
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_value(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'account-category': accountCategory,
             'orderId': id,
@@ -1822,7 +1822,7 @@ class ascendex(Exchange, ImplicitAPI):
         type, query = self.handle_market_type_and_params('fetchOpenOrders', market, params)
         accountsByType = self.safe_value(self.options, 'accountsByType', {})
         accountCategory = self.safe_string(accountsByType, type, 'cash')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'account-category': accountCategory,
         }
@@ -1927,7 +1927,7 @@ class ascendex(Exchange, ImplicitAPI):
         await self.load_accounts()
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_value(account, 'id')
-        request = {
+        request: dict = {
             # 'category': accountCategory,
             # 'symbol': market['id'],
             # 'orderType': 'market',  # optional, string
@@ -2094,7 +2094,7 @@ class ascendex(Exchange, ImplicitAPI):
         accountCategory = self.safe_string(accountsByType, type, 'cash')
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_value(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'account-category': accountCategory,
             'symbol': market['id'],
@@ -2201,7 +2201,7 @@ class ascendex(Exchange, ImplicitAPI):
         accountCategory = self.safe_string(accountsByType, type, 'cash')
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_value(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'account-category': accountCategory,
             'time': self.milliseconds(),
@@ -2299,7 +2299,7 @@ class ascendex(Exchange, ImplicitAPI):
         networkCode = self.safe_string_2(params, 'network', 'chainName')
         networkId = self.network_code_to_id(networkCode)
         params = self.omit(params, ['chainName'])
-        request = {
+        request: dict = {
             'asset': currency['id'],
             'blockchain': networkId,
         }
@@ -2365,7 +2365,7 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
-        request = {
+        request: dict = {
             'txType': 'deposit',
         }
         return await self.fetch_transactions(code, since, limit, self.extend(request, params))
@@ -2379,7 +2379,7 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
-        request = {
+        request: dict = {
             'txType': 'withdrawal',
         }
         return await self.fetch_transactions(code, since, limit, self.extend(request, params))
@@ -2394,7 +2394,7 @@ class ascendex(Exchange, ImplicitAPI):
         :returns dict: a list of `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         await self.load_markets()
-        request = {
+        request: dict = {
             # 'asset': currency['id'],
             # 'page': 1,
             # 'pageSize': 20,
@@ -2441,7 +2441,7 @@ class ascendex(Exchange, ImplicitAPI):
         return self.parse_transactions(transactions, currency, since, limit)
 
     def parse_transaction_status(self, status):
-        statuses = {
+        statuses: dict = {
             'reviewing': 'pending',
             'pending': 'pending',
             'confirmed': 'ok',
@@ -2449,7 +2449,7 @@ class ascendex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         #     {
         #         "requestId": "wuzd1Ojsqtz4bCA3UXwtUnnJDmU8PiyB",
@@ -2515,7 +2515,7 @@ class ascendex(Exchange, ImplicitAPI):
         await self.load_accounts()
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
         }
         response = await self.v2PrivateAccountGroupGetFuturesPosition(self.extend(request, params))
@@ -2566,7 +2566,7 @@ class ascendex(Exchange, ImplicitAPI):
         symbols = self.market_symbols(symbols)
         return self.filter_by_array_positions(result, 'symbol', symbols, False)
 
-    def parse_position(self, position, market: Market = None):
+    def parse_position(self, position: dict, market: Market = None):
         #
         #     {
         #         "symbol": "BTC-PERP",
@@ -2712,7 +2712,7 @@ class ascendex(Exchange, ImplicitAPI):
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
         amount = self.amount_to_precision(symbol, amount)
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'symbol': market['id'],
             'amount': amount,  # positive value for adding margin, negative for reducing
@@ -2795,7 +2795,7 @@ class ascendex(Exchange, ImplicitAPI):
             raise BadSymbol(self.id + ' setLeverage() supports swap contracts only')
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'symbol': market['id'],
             'leverage': leverage,
@@ -2823,7 +2823,7 @@ class ascendex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'symbol': market['id'],
             'marginType': marginMode,
@@ -2832,7 +2832,7 @@ class ascendex(Exchange, ImplicitAPI):
             raise BadSymbol(self.id + ' setMarginMode() supports swap contracts only')
         return await self.v2PrivateAccountGroupPostFuturesMarginType(self.extend(request, params))
 
-    async def fetch_leverage_tiers(self, symbols: Strings = None, params={}):
+    async def fetch_leverage_tiers(self, symbols: Strings = None, params={}) -> LeverageTiers:
         """
         retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes
         :param str[]|None symbols: list of unified market symbols
@@ -2873,7 +2873,7 @@ class ascendex(Exchange, ImplicitAPI):
         symbols = self.market_symbols(symbols)
         return self.parse_leverage_tiers(data, symbols, 'symbol')
 
-    def parse_market_leverage_tiers(self, info, market: Market = None):
+    def parse_market_leverage_tiers(self, info, market: Market = None) -> List[LeverageTier]:
         """
         :param dict info: Exchange market response for 1 market
         :param dict market: CCXT market
@@ -2941,7 +2941,7 @@ class ascendex(Exchange, ImplicitAPI):
         #
         blockChains = self.safe_value(fee, 'blockChain', [])
         blockChainsLength = len(blockChains)
-        result = {
+        result: dict = {
             'info': fee,
             'withdraw': {
                 'fee': None,
@@ -3000,7 +3000,7 @@ class ascendex(Exchange, ImplicitAPI):
         toId = self.safe_string(accountsByType, toAccount, toAccount)
         if fromId != 'cash' and toId != 'cash':
             raise ExchangeError(self.id + ' transfer() only supports direct balance transfer between spot and swap, spot and margin')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
             'amount': self.currency_to_precision(code, amount),
             'asset': currency['id'],
@@ -3063,7 +3063,7 @@ class ascendex(Exchange, ImplicitAPI):
             return await self.fetch_paginated_call_incremental('fetchFundingHistory', symbol, since, limit, params, 'page', 25)
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
         }
         market = None
@@ -3116,7 +3116,7 @@ class ascendex(Exchange, ImplicitAPI):
             'amount': self.safe_number(income, 'paymentInUSDT'),
         }
 
-    async def fetch_margin_modes(self, symbols: List[str] = None, params={}) -> MarginModes:
+    async def fetch_margin_modes(self, symbols: Strings = None, params={}) -> MarginModes:
         """
         fetches the set margin mode of the user
         :see: https://ascendex.github.io/ascendex-futures-pro-api-v2/#position
@@ -3128,7 +3128,7 @@ class ascendex(Exchange, ImplicitAPI):
         await self.load_accounts()
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
         }
         response = await self.v2PrivateAccountGroupGetFuturesPosition(self.extend(request, params))
@@ -3175,7 +3175,7 @@ class ascendex(Exchange, ImplicitAPI):
         marginModes = self.safe_list(data, 'contracts', [])
         return self.parse_margin_modes(marginModes, symbols, 'symbol')
 
-    def parse_margin_mode(self, marginMode, market=None) -> MarginMode:
+    def parse_margin_mode(self, marginMode: dict, market=None) -> MarginMode:
         marketId = self.safe_string(marginMode, 'symbol')
         marginType = self.safe_string(marginMode, 'marginType')
         margin = 'cross' if (marginType == 'crossed') else 'isolated'
@@ -3185,7 +3185,7 @@ class ascendex(Exchange, ImplicitAPI):
             'marginMode': margin,
         }
 
-    async def fetch_leverages(self, symbols: List[str] = None, params={}) -> Leverages:
+    async def fetch_leverages(self, symbols: Strings = None, params={}) -> Leverages:
         """
         fetch the set leverage for all contract markets
         :see: https://ascendex.github.io/ascendex-futures-pro-api-v2/#position
@@ -3197,7 +3197,7 @@ class ascendex(Exchange, ImplicitAPI):
         await self.load_accounts()
         account = self.safe_value(self.accounts, 0, {})
         accountGroup = self.safe_string(account, 'id')
-        request = {
+        request: dict = {
             'account-group': accountGroup,
         }
         response = await self.v2PrivateAccountGroupGetFuturesPosition(self.extend(request, params))

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.29'
+__version__ = '4.3.31'
 
 # -----------------------------------------------------------------------------
 
@@ -586,7 +586,7 @@ class Exchange(BaseExchange):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchOrderBookForSymbols() is not supported yet')
 
-    async def fetch_deposit_addresses(self, codes: List[str] = None, params={}):
+    async def fetch_deposit_addresses(self, codes: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchDepositAddresses() is not supported yet')
 
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}):
@@ -599,7 +599,7 @@ class Exchange(BaseExchange):
         else:
             raise NotSupported(self.id + ' fetchMarginMode() is not supported yet')
 
-    async def fetch_margin_modes(self, symbols: List[str] = None, params={}):
+    async def fetch_margin_modes(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchMarginModes() is not supported yet')
 
     async def fetch_rest_order_book_safe(self, symbol, limit=None, params={}):
@@ -619,7 +619,7 @@ class Exchange(BaseExchange):
     async def fetch_time(self, params={}):
         raise NotSupported(self.id + ' fetchTime() is not supported yet')
 
-    async def fetch_trading_limits(self, symbols: List[str] = None, params={}):
+    async def fetch_trading_limits(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchTradingLimits() is not supported yet')
 
     async def fetch_cross_borrow_rates(self, params={}):
@@ -628,10 +628,10 @@ class Exchange(BaseExchange):
     async def fetch_isolated_borrow_rates(self, params={}):
         raise NotSupported(self.id + ' fetchIsolatedBorrowRates() is not supported yet')
 
-    async def fetch_leverage_tiers(self, symbols: List[str] = None, params={}):
+    async def fetch_leverage_tiers(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchLeverageTiers() is not supported yet')
 
-    async def fetch_funding_rates(self, symbols: List[str] = None, params={}):
+    async def fetch_funding_rates(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchFundingRates() is not supported yet')
 
     async def watch_funding_rate(self, symbol: str, params={}):
@@ -662,7 +662,7 @@ class Exchange(BaseExchange):
         else:
             raise NotSupported(self.id + ' fetchLeverage() is not supported yet')
 
-    async def fetch_leverages(self, symbols: List[str] = None, params={}):
+    async def fetch_leverages(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchLeverages() is not supported yet')
 
     async def set_position_mode(self, hedged: bool, symbol: Str = None, params={}):
@@ -791,7 +791,7 @@ class Exchange(BaseExchange):
             'bids': self.sort_by(self.aggregate(orderbook['bids']), 0, True),
         })
 
-    async def load_trading_limits(self, symbols: List[str] = None, reload=False, params={}):
+    async def load_trading_limits(self, symbols: Strings = None, reload=False, params={}):
         if self.has['fetchTradingLimits']:
             if reload or not ('limitsLoaded' in self.options):
                 response = await self.fetch_trading_limits(symbols)
@@ -855,10 +855,10 @@ class Exchange(BaseExchange):
     async def watch_position(self, symbol: Str = None, params={}):
         raise NotSupported(self.id + ' watchPosition() is not supported yet')
 
-    async def watch_positions(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}):
+    async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchPositions() is not supported yet')
 
-    async def watch_position_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}):
+    async def watch_position_for_symbols(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}):
         return await self.watchPositions(symbols, since, limit, params)
 
     async def fetch_positions_for_symbol(self, symbol: str, params={}):
@@ -879,13 +879,13 @@ class Exchange(BaseExchange):
         """
         raise NotSupported(self.id + ' fetchPositionsForSymbol() is not supported yet')
 
-    async def fetch_positions(self, symbols: List[str] = None, params={}):
+    async def fetch_positions(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchPositions() is not supported yet')
 
-    async def fetch_positions_ws(self, symbols: List[str] = None, params={}):
+    async def fetch_positions_ws(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchPositions() is not supported yet')
 
-    async def fetch_positions_risk(self, symbols: List[str] = None, params={}):
+    async def fetch_positions_risk(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchPositionsRisk() is not supported yet')
 
     async def fetch_bids_asks(self, symbols: Strings = None, params={}):
@@ -930,10 +930,10 @@ class Exchange(BaseExchange):
             raise NotSupported(self.id + ' fetchTransactionFee() is not supported yet')
         return await self.fetch_transaction_fees([code], params)
 
-    async def fetch_transaction_fees(self, codes: List[str] = None, params={}):
+    async def fetch_transaction_fees(self, codes: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchTransactionFees() is not supported yet')
 
-    async def fetch_deposit_withdraw_fees(self, codes: List[str] = None, params={}):
+    async def fetch_deposit_withdraw_fees(self, codes: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchDepositWithdrawFees() is not supported yet')
 
     async def fetch_deposit_withdraw_fee(self, code: str, params={}):
@@ -993,19 +993,19 @@ class Exchange(BaseExchange):
     async def watch_ticker(self, symbol: str, params={}):
         raise NotSupported(self.id + ' watchTicker() is not supported yet')
 
-    async def fetch_tickers(self, symbols: List[str] = None, params={}):
+    async def fetch_tickers(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchTickers() is not supported yet')
 
-    async def fetch_tickers_ws(self, symbols: List[str] = None, params={}):
+    async def fetch_tickers_ws(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchTickers() is not supported yet')
 
-    async def fetch_order_books(self, symbols: List[str] = None, limit: Int = None, params={}):
+    async def fetch_order_books(self, symbols: Strings = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' fetchOrderBooks() is not supported yet')
 
     async def watch_bids_asks(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' watchBidsAsks() is not supported yet')
 
-    async def watch_tickers(self, symbols: List[str] = None, params={}):
+    async def watch_tickers(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' watchTickers() is not supported yet')
 
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
@@ -1603,7 +1603,7 @@ class Exchange(BaseExchange):
         query = self.extend(params, {'stopPrice': stopPrice})
         return await self.createOrderWs(symbol, 'market', side, amount, None, query)
 
-    async def fetch_last_prices(self, symbols: List[str] = None, params={}):
+    async def fetch_last_prices(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchLastPrices() is not supported yet')
 
     async def fetch_trading_fees(self, params={}):
@@ -1648,7 +1648,7 @@ class Exchange(BaseExchange):
         :returns float[][]: A list of candles ordered, open, high, low, close, None
         """
         if self.has['fetchMarkOHLCV']:
-            request = {
+            request: dict = {
                 'price': 'mark',
             }
             return await self.fetch_ohlcv(symbol, timeframe, since, limit, self.extend(request, params))
@@ -1666,7 +1666,7 @@ class Exchange(BaseExchange):
          * @returns {} A list of candles ordered, open, high, low, close, None
         """
         if self.has['fetchIndexOHLCV']:
-            request = {
+            request: dict = {
                 'price': 'index',
             }
             return await self.fetch_ohlcv(symbol, timeframe, since, limit, self.extend(request, params))
@@ -1684,7 +1684,7 @@ class Exchange(BaseExchange):
         :returns float[][]: A list of candles ordered, open, high, low, close, None
         """
         if self.has['fetchPremiumIndexOHLCV']:
-            request = {
+            request: dict = {
                 'price': 'premiumIndex',
             }
             return await self.fetch_ohlcv(symbol, timeframe, since, limit, self.extend(request, params))

ccxt/async_support/base/ws/aiohttp_client.py

@@ -101,6 +101,7 @@ class AiohttpClient(Client):
                 else:
                     future.reject(ExchangeClosedByUser('Connection closed by the user'))
 
+
     async def ping_loop(self):
         if self.verbose:
             self.log(iso8601(milliseconds()), 'ping loop')

ccxt/async_support/base/ws/future.py

@@ -1,7 +1,6 @@
 import asyncio
 from ccxt import ExchangeClosedByUser
 
-
 class Future(asyncio.Future):
 
     is_race_future = False
@@ -23,38 +22,37 @@ class Future(asyncio.Future):
         task = asyncio.create_task(coro)
 
         def callback(done):
-            exception = done.exception()
-            if exception is None:
-                complete, _ = done.result()
+            try:
+                complete, pending = done.result()
                 # check for exceptions
-                exceptions = []
-                for f in complete:
-                    if f._state == 'CANCELLED':
-                        continue  # was canceled internally
-                    err = f.exception()
-                    if err:
-                        exceptions.append(err)
-                # if any exceptions return with first exception
-                if len (exceptions) > 0:
-                    future.set_exception(exceptions[0])
-                    return
-                # else return first result
-                else:
-                    futures_list = list(complete)
-                    are_all_canceled = all(f._state == 'CANCELLED' for f in futures_list)
-                    if are_all_canceled and future._state == 'PENDING':
-                        future.set_exception(ExchangeClosedByUser('Connection closed by the user'))
+                for i, f in enumerate(complete):
+                    try:
+                        f.result()
+                    except ExchangeClosedByUser as e:
+                        if len(pending) == 0 and i == len(complete) - 1:
+                            future.reject(e)
+                        # wait for all the sub promises to be reject before rejecting future
+                        continue
+                    except asyncio.CancelledError as e:
+                        continue
+                    except Exception as e:
+                        future.reject(e)
                         return
+                # no exceptions return first result
+                futures_list = list(complete)
 
-                    # handle wait_for scenario
-                    if are_all_canceled and future._state == 'CANCELLED':
-                        return
+                are_all_canceled = all([f.cancelled() for f in futures_list])
+                if are_all_canceled:
+                    future.reject(ExchangeClosedByUser('Connection closed by the user'))
+                    return
 
-                    first = futures_list[0]
+                first = futures_list[0]
 
-                    first_result = first.result()
-                    future.set_result(first_result)
-            else:
-                future.set_exception(exception)
+                first_result = first.result()
+                future.resolve(first_result)
+            except asyncio.CancelledError as e:
+                future.reject(e)
+            except Exception as e:
+                future.reject(e)
         task.add_done_callback(callback)
         return future