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

ccxt/kucoinfutures.py

@@ -5,7 +5,7 @@
 
 from ccxt.kucoin import kucoin
 from ccxt.abstract.kucoinfutures import ImplicitAPI
-from ccxt.base.types import Balances, Currency, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currency, Int, LeverageTier, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
@@ -568,7 +568,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         market = self.market(symbol)
         marketId = market['id']
         parsedTimeframe = self.safe_integer(self.timeframes, timeframe)
-        request = {
+        request: dict = {
             'symbol': marketId,
         }
         if parsedTimeframe is not None:
@@ -632,7 +632,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         self.load_markets()
         currency = self.currency(code)
         currencyId = currency['id']
-        request = {
+        request: dict = {
             'currency': currencyId,  # Currency,including XBT,USDT
         }
         response = self.futuresPrivateGetDepositAddress(self.extend(request, params))
@@ -672,7 +672,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         if level != 2 and level is not None:
             raise BadRequest(self.id + ' fetchOrderBook() can only return level 2')
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -717,7 +717,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.futuresPublicGetTicker(self.extend(request, params))
@@ -938,7 +938,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchFundingHistory() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if since is not None:
@@ -1000,7 +1000,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.futuresPrivateGetPosition(self.extend(request, params))
@@ -1123,7 +1123,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         self.load_markets()
         if limit is None:
             limit = 200
-        request = {
+        request: dict = {
             'limit': limit,
         }
         if since is not None:
@@ -1175,7 +1175,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         items = self.safe_list(data, 'items', [])
         return self.parse_positions(items, symbols)
 
-    def parse_position(self, position, market: Market = None):
+    def parse_position(self, position: dict, market: Market = None):
         #
         #    {
         #        "code": "200000",
@@ -1403,7 +1403,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         if amount < 1:
             raise InvalidOrder(self.id + ' createOrder() minimum contract order amount is 1')
         preciseAmount = int(self.amount_to_precision(symbol, amount))
-        request = {
+        request: dict = {
             'clientOid': clientOrderId,
             'side': side,
             'symbol': market['id'],
@@ -1412,7 +1412,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
             'leverage': 1,
         }
         triggerPrice, stopLossPrice, takeProfitPrice = self.handle_trigger_prices(params)
-        triggerPriceTypes = {
+        triggerPriceTypes: dict = {
             'mark': 'MP',
             'last': 'TP',
             'index': 'IP',
@@ -1470,7 +1470,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         self.load_markets()
         clientOrderId = self.safe_string_2(params, 'clientOid', 'clientOrderId')
         params = self.omit(params, ['clientOrderId'])
-        request = {}
+        request: dict = {}
         response = None
         if clientOrderId is not None:
             if symbol is None:
@@ -1505,7 +1505,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :returns: Response from the exchange
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         if symbol is not None:
             request['symbol'] = self.market_id(symbol)
         stop = self.safe_value_2(params, 'stop', 'trigger')
@@ -1539,7 +1539,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         uuid = self.uuid()
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'margin': self.amount_to_precision(symbol, amount),
             'bizNo': uuid,
@@ -1695,7 +1695,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
             status = 'done'
         elif status == 'open':
             status = 'active'
-        request = {}
+        request: dict = {}
         if not stop:
             request['status'] = status
         elif status != 'active':
@@ -1821,7 +1821,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         response = None
         if id is None:
             clientOrderId = self.safe_string_2(params, 'clientOid', 'clientOrderId')
@@ -1880,7 +1880,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         responseData = self.safe_dict(response, 'data')
         return self.parse_order(responseData, market)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # fetchOrder, fetchOrdersByStatus
         #
@@ -2021,7 +2021,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.futuresPublicGetFundingRateSymbolCurrent(self.extend(request, params))
@@ -2061,7 +2061,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         }
 
     def parse_balance(self, response) -> Balances:
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': None,
             'datetime': None,
@@ -2089,7 +2089,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         defaultCode = self.safe_string(fetchBalanceOptions, 'code', defaultCode)
         code = self.safe_string(params, 'code', defaultCode)
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'],
         }
         response = self.futuresPrivateGetAccountOverview(self.extend(request, params))
@@ -2125,7 +2125,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         self.load_markets()
         currency = self.currency(code)
         amountToPrecision = self.currency_to_precision(code, amount)
-        request = {
+        request: dict = {
             'currency': self.safe_string(currency, 'id'),  # Currency,including XBT,USDT
             'amount': amountToPrecision,
         }
@@ -2168,7 +2168,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         }
 
     def parse_transfer_status(self, status: Str) -> Str:
-        statuses = {
+        statuses: dict = {
             'PROCESSING': 'pending',
         }
         return self.safe_string(statuses, status, status)
@@ -2190,7 +2190,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchMyTrades', 'paginate')
         if paginate:
             return self.fetch_paginated_call_dynamic('fetchMyTrades', symbol, since, limit, params)
-        request = {
+        request: dict = {
             # orderId(str) [optional] Fills for a specific order(other parameters can be ignored if specified)
             # symbol(str) [optional] Symbol of the contract
             # side(str) [optional] buy or sell
@@ -2255,7 +2255,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.futuresPublicGetTradeHistory(self.extend(request, params))
@@ -2279,7 +2279,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         trades = self.safe_list(response, 'data', [])
         return self.parse_trades(trades, market, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchTrades(public)
         #
@@ -2417,7 +2417,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -2467,7 +2467,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -2507,7 +2507,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         responseData = response['data']['items']
         return self.parse_transactions(responseData, currency, since, limit, {'type': 'withdrawal'})
 
-    def fetch_market_leverage_tiers(self, symbol: str, params={}):
+    def fetch_market_leverage_tiers(self, symbol: str, params={}) -> List[LeverageTier]:
         """
         retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes for a single market
         :see: https://www.kucoin.com/docs/rest/futures-trading/risk-limit/get-futures-risk-limit-level
@@ -2519,7 +2519,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         market = self.market(symbol)
         if not market['contract']:
             raise BadRequest(self.id + ' fetchMarketLeverageTiers() supports contract markets only')
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.futuresPublicGetContractsRiskLimitSymbol(self.extend(request, params))
@@ -2543,7 +2543,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         data = self.safe_value(response, 'data')
         return self.parse_market_leverage_tiers(data, market)
 
-    def parse_market_leverage_tiers(self, info, market: Market = None):
+    def parse_market_leverage_tiers(self, info, market: Market = None) -> List[LeverageTier]:
         """
          * @ignore
         :param dict info: Exchange market response for 1 market
@@ -2589,7 +2589,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchFundingRateHistory() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'from': 0,
             'to': self.milliseconds(),
@@ -2648,7 +2648,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         params = self.omit(params, ['test', 'clientOrderId'])
         if clientOrderId is None:
             clientOrderId = self.number_to_string(self.nonce())
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'closeOrder': True,
             'clientOid': clientOrderId,
@@ -2671,7 +2671,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbols': market['id'],
         }
         response = self.privateGetTradeFees(self.extend(request, params))

ccxt/kuna.py

@@ -462,13 +462,13 @@ class kuna(Exchange, ImplicitAPI):
 
     def parse_currencies(self, currencies, params={}):
         currencies = self.to_array(currencies)
-        result = {}
+        result: dict = {}
         for i in range(0, len(currencies)):
             currency = self.parse_currency(currencies[i])
             result[currency['code']] = currency
         return result
 
-    def parse_currency(self, currency):
+    def parse_currency(self, currency: dict):
         #
         #    {
         #        "code": "BTC",
@@ -618,7 +618,7 @@ class kuna(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pairs': market['id'],
         }
         if limit is not None:
@@ -704,7 +704,7 @@ class kuna(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchTickers() requires a symbols argument')
         symbols = self.market_symbols(symbols)
         marketIds = self.market_ids(symbols)
-        request = {
+        request: dict = {
             'pairs': ','.join(marketIds),
         }
         response = self.v4PublicGetMarketsPublicTickersPairsPairs(self.extend(request, params))
@@ -741,7 +741,7 @@ class kuna(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pairs': market['id'],
         }
         response = self.v4PublicGetMarketsPublicTickersPairsPairs(self.extend(request, params))
@@ -792,7 +792,7 @@ class kuna(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pairs': market['id'],
         }
         if limit is not None:
@@ -817,7 +817,7 @@ class kuna(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_trades(data, market, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchTrades(public)
         #
@@ -885,7 +885,7 @@ class kuna(Exchange, ImplicitAPI):
         #        ...
         #    ]
         #
-        result = {'info': response}
+        result: dict = {'info': response}
         for i in range(0, len(response)):
             balance = response[i]
             currencyId = self.safe_string(balance, 'currency')
@@ -938,7 +938,7 @@ class kuna(Exchange, ImplicitAPI):
         triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
         params = self.omit(params, ['triggerPrice', 'stopPrice'])
         capitalizedType = self.capitalize(type)
-        request = {
+        request: dict = {
             'pair': market['id'],
             'orderSide': 'Bid' if (side == 'buy') else 'Ask',
             'quantity': self.number_to_string(amount),
@@ -980,7 +980,7 @@ class kuna(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'orderId': id,
         }
         response = self.v4PrivatePostOrderPrivateCancel(self.extend(request, params))
@@ -1008,7 +1008,7 @@ class kuna(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'orderIds': ids,
         }
         response = self.v4PrivatePostOrderPrivateCancelMulti(self.extend(request, params))
@@ -1026,8 +1026,8 @@ class kuna(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_orders(data)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'Canceled': 'canceled',
             'Closed': 'filled',
             'Pending': 'open',
@@ -1038,7 +1038,7 @@ class kuna(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, fetchOrder, fetchOpenOrders, fetchOrdersByStatus
         #
@@ -1126,7 +1126,7 @@ class kuna(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'id': id,
             'withTrades': True,
         }
@@ -1186,7 +1186,7 @@ class kuna(Exchange, ImplicitAPI):
         until = self.safe_integer(params, 'until')
         params = self.omit(params, ['until'])
         market = None
-        request = {
+        request: dict = {
         }
         if symbol is not None:
             market = self.market(symbol)
@@ -1259,7 +1259,7 @@ class kuna(Exchange, ImplicitAPI):
         until = self.safe_integer(params, 'until')
         params = self.omit(params, ['until'])
         market = None
-        request = {
+        request: dict = {
             'status': self.capitalize(status),
         }
         if symbol is not None:
@@ -1313,7 +1313,7 @@ class kuna(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = None
-        request = {}
+        request: dict = {}
         if symbol is not None:
             market = self.market(symbol)
             request['pair'] = market['id']
@@ -1367,7 +1367,7 @@ class kuna(Exchange, ImplicitAPI):
             else:
                 chain = currency['id'].upper()
         networkId = self.network_code_to_id(chain)
-        request = {
+        request: dict = {
             'currency': networkId,
             'amount': amount,
             'address': address,
@@ -1411,7 +1411,7 @@ class kuna(Exchange, ImplicitAPI):
         currency = None
         if code is not None:
             currency = self.currency(code)
-        request = {}
+        request: dict = {}
         if code is not None:
             request['currency'] = code
         if since is not None:
@@ -1458,7 +1458,7 @@ class kuna(Exchange, ImplicitAPI):
         :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'withdrawId': id,
         }
         response = self.v4PrivateGetWithdrawPrivateDetailsWithdrawId(self.extend(request, params))
@@ -1496,7 +1496,7 @@ class kuna(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'source': currency['id'],
         }
         response = self.v4PrivatePostDepositPrivateCryptoGenerateAddress(self.extend(request, params))
@@ -1522,7 +1522,7 @@ class kuna(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'source': currency['id'].upper(),
         }
         response = self.v4PrivateGetDepositPrivateCryptoAddress(self.extend(request, params))
@@ -1556,7 +1556,7 @@ class kuna(Exchange, ImplicitAPI):
         }
 
     def parse_transaction_status(self, status):
-        statuses = {
+        statuses: dict = {
             'Created': 'pending',
             'Canceled': 'canceled',
             'PartiallyProcessed': 'pending',
@@ -1592,7 +1592,7 @@ class kuna(Exchange, ImplicitAPI):
         currency = None
         if code is not None:
             currency = self.currency(code)
-        request = {}
+        request: dict = {}
         if code is not None:
             request['currency'] = code
         if since is not None:
@@ -1642,7 +1642,7 @@ class kuna(Exchange, ImplicitAPI):
         currency = None
         if code is not None:
             currency = self.currency(code)
-        request = {
+        request: dict = {
             'depositId': id,
         }
         response = self.v4PrivateGetDepositPrivateDetailsDepositId(self.extend(request, params))
@@ -1670,7 +1670,7 @@ class kuna(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data, currency)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         #    {
         #        "id": "a201cb3c-5830-57ac-ad2c-f6a588dd55eb",                               # Unique ID of deposit