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

ccxt/gate.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.gate import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currencies, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, MarginModification, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currencies, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, LeverageTier, LeverageTiers, MarginModification, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -1100,7 +1100,7 @@ class gate(Exchange, ImplicitAPI):
         futureSettlementCurrencies = self.get_settlement_currencies('future', 'fetchMarkets')
         for c in range(0, len(swapSettlementCurrencies)):
             settleId = swapSettlementCurrencies[c]
-            request = {
+            request: dict = {
                 'settle': settleId,
             }
             response = self.publicFuturesGetSettleContracts(self.extend(request, params))
@@ -1109,7 +1109,7 @@ class gate(Exchange, ImplicitAPI):
                 result.append(parsedMarket)
         for c in range(0, len(futureSettlementCurrencies)):
             settleId = futureSettlementCurrencies[c]
-            request = {
+            request: dict = {
                 'settle': settleId,
             }
             response = self.publicDeliveryGetSettleContracts(self.extend(request, params))
@@ -1435,7 +1435,7 @@ class gate(Exchange, ImplicitAPI):
         :returns: the api request object, and the new params object with non-needed parameters removed
         """
         # * Do not call for multi spot order methods like cancelAllOrders and fetchOpenOrders. Use multiOrderSpotPrepareRequest instead
-        request = {}
+        request: dict = {}
         if market is not None:
             if market['contract']:
                 request['contract'] = market['id']
@@ -1463,7 +1463,7 @@ class gate(Exchange, ImplicitAPI):
         :returns: the api request object, and the new params object with non-needed parameters removed
         """
         marginMode, query = self.get_margin_mode(stop, params)
-        request = {}
+        request: dict = {}
         if not stop:
             if market is None:
                 raise ArgumentsRequired(self.id + ' spotOrderPrepareRequest() requires a market argument for non-stop orders')
@@ -1481,7 +1481,7 @@ class gate(Exchange, ImplicitAPI):
         :returns: the api request object, and the new params object with non-needed parameters removed
         """
         marginMode, query = self.get_margin_mode(stop, params)
-        request = {
+        request: dict = {
             'account': marginMode,
         }
         if market is not None:
@@ -1555,7 +1555,7 @@ class gate(Exchange, ImplicitAPI):
         #        "chain":"ETH"
         #    }
         #
-        result = {}
+        result: dict = {}
         for i in range(0, len(response)):
             entry = response[i]
             currencyId = self.safe_string(entry, 'currency')
@@ -1825,14 +1825,14 @@ class gate(Exchange, ImplicitAPI):
     def fetch_network_deposit_address(self, code: str, params={}):
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'],  # todo: currencies have network-junctions
         }
         response = self.privateWalletGetDepositAddress(self.extend(request, params))
         addresses = self.safe_value(response, 'multichain_addresses')
         currencyId = self.safe_string(response, 'currency')
         code = self.safe_currency_code(currencyId)
-        result = {}
+        result: dict = {}
         for i in range(0, len(addresses)):
             entry = addresses[i]
             #
@@ -1872,7 +1872,7 @@ class gate(Exchange, ImplicitAPI):
         currency = self.currency(code)
         rawNetwork = self.safe_string_upper(params, 'network')
         params = self.omit(params, 'network')
-        request = {
+        request: dict = {
             'currency': currency['id'],  # todo: currencies have network-junctions
         }
         response = self.privateWalletGetDepositAddress(self.extend(request, params))
@@ -1941,7 +1941,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currency_pair': market['id'],
         }
         response = self.privateWalletGetFee(self.extend(request, params))
@@ -1987,7 +1987,7 @@ class gate(Exchange, ImplicitAPI):
         return self.parse_trading_fees(response)
 
     def parse_trading_fees(self, response):
-        result = {}
+        result: dict = {}
         for i in range(0, len(self.symbols)):
             symbol = self.symbols[i]
             market = self.market(symbol)
@@ -2024,7 +2024,7 @@ class gate(Exchange, ImplicitAPI):
             'tierBased': None,
         }
 
-    def fetch_transaction_fees(self, codes: List[str] = None, params={}):
+    def fetch_transaction_fees(self, codes: Strings = None, params={}):
         """
          * @deprecated
         please use fetchDepositWithdrawFees instead
@@ -2052,7 +2052,7 @@ class gate(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        result = {}
+        result: dict = {}
         withdrawFees = {}
         for i in range(0, len(response)):
             withdrawFees = {}
@@ -2126,7 +2126,7 @@ class gate(Exchange, ImplicitAPI):
         #    }
         #
         withdrawFixOnChains = self.safe_value(fee, 'withdraw_fix_on_chains')
-        result = {
+        result: dict = {
             'info': fee,
             'withdraw': {
                 'fee': self.safe_number(fee, 'withdraw_fix'),
@@ -2247,7 +2247,7 @@ class gate(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         #
-        #     request = {
+        #     request: Dict = {
         #         'currency_pair': market['id'],
         #         'interval': '0',  # depth, 0 means no aggregation is applied, default to 0
         #         'limit': limit,  # maximum number of order depth data in asks or bids
@@ -2719,7 +2719,7 @@ class gate(Exchange, ImplicitAPI):
         #         "orders_limit": 10
         #     }
         #
-        result = {
+        result: dict = {
             'info': response,
         }
         isolated = marginMode == 'margin'
@@ -2745,7 +2745,7 @@ class gate(Exchange, ImplicitAPI):
                 quote = self.safe_value(entry, 'quote', {})
                 baseCode = self.safe_currency_code(self.safe_string(base, 'currency'))
                 quoteCode = self.safe_currency_code(self.safe_string(quote, 'currency'))
-                subResult = {}
+                subResult: dict = {}
                 subResult[baseCode] = self.parse_balance_helper(base)
                 subResult[quoteCode] = self.parse_balance_helper(quote)
                 result[symbolInner] = self.safe_balance(subResult)
@@ -2781,7 +2781,7 @@ class gate(Exchange, ImplicitAPI):
         if market['option']:
             return self.fetch_option_ohlcv(symbol, timeframe, since, limit, params)
         price = self.safe_string(params, 'price')
-        request = {}
+        request: dict = {}
         request, params = self.prepare_request(market, None, params)
         request['interval'] = self.safe_string(self.timeframes, timeframe, timeframe)
         maxLimit = 1999 if market['contract'] else 1000
@@ -2825,7 +2825,7 @@ class gate(Exchange, ImplicitAPI):
         # separated option logic because the from, to and limit parameters weren't functioning
         self.load_markets()
         market = self.market(symbol)
-        request = {}
+        request: dict = {}
         request, params = self.prepare_request(market, None, params)
         request['interval'] = self.safe_string(self.timeframes, timeframe, timeframe)
         response = self.publicOptionsGetCandlesticks(self.extend(request, params))
@@ -2940,7 +2940,7 @@ class gate(Exchange, ImplicitAPI):
         #
         # spot
         #
-        #     request = {
+        #     request: Dict = {
         #         'currency_pair': market['id'],
         #         'limit': limit,  # maximum number of records to be returned in a single list
         #         'last_id': 'id',  # specify list staring point using the id of last record in previous list-query results
@@ -2949,7 +2949,7 @@ class gate(Exchange, ImplicitAPI):
         #
         # swap, future
         #
-        #     request = {
+        #     request: Dict = {
         #         'settle': market['settleId'],
         #         'contract': market['id'],
         #         'limit': limit,  # maximum number of records to be returned in a single list
@@ -3089,7 +3089,7 @@ class gate(Exchange, ImplicitAPI):
             return self.fetch_paginated_call_dynamic('fetchMyTrades', symbol, since, limit, params)
         type = None
         marginMode = None
-        request = {}
+        request: dict = {}
         market = self.market(symbol) if (symbol is not None) else None
         until = self.safe_integer(params, 'until')
         params = self.omit(params, ['until'])
@@ -3187,7 +3187,7 @@ class gate(Exchange, ImplicitAPI):
         #
         return self.parse_trades(response, market, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # public
         #
@@ -3346,7 +3346,7 @@ class gate(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchDeposits', 'paginate')
         if paginate:
             return self.fetch_paginated_call_dynamic('fetchDeposits', code, since, limit, params)
-        request = {}
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -3378,7 +3378,7 @@ class gate(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchWithdrawals', 'paginate')
         if paginate:
             return self.fetch_paginated_call_dynamic('fetchWithdrawals', code, since, limit, params)
-        request = {}
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -3408,7 +3408,7 @@ class gate(Exchange, ImplicitAPI):
         self.check_address(address)
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'],  # todo: currencies have network-junctions
             'address': address,
             'amount': self.currency_to_precision(code, amount),
@@ -3436,7 +3436,7 @@ class gate(Exchange, ImplicitAPI):
         return self.parse_transaction(response, currency)
 
     def parse_transaction_status(self, status):
-        statuses = {
+        statuses: dict = {
             'PEND': 'pending',
             'REQUEST': 'pending',
             'DMOVE': 'pending',
@@ -3454,13 +3454,13 @@ class gate(Exchange, ImplicitAPI):
         return self.safe_string(statuses, status, status)
 
     def parse_transaction_type(self, type):
-        types = {
+        types: dict = {
             'd': 'deposit',
             'w': 'withdrawal',
         }
         return self.safe_string(types, type, type)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         # deposits
         #
@@ -3952,7 +3952,7 @@ class gate(Exchange, ImplicitAPI):
             if not isLimitOrder:
                 # exchange doesn't have market orders for spot
                 raise InvalidOrder(self.id + ' editOrder() does not support ' + type + ' orders for ' + marketType + ' markets')
-        request = {
+        request: dict = {
             'order_id': id,
             'currency_pair': market['id'],
             'account': account,
@@ -4006,8 +4006,8 @@ class gate(Exchange, ImplicitAPI):
         #
         return self.parse_order(response, market)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'open': 'open',
             '_new': 'open',
             'filled': 'closed',
@@ -4022,7 +4022,7 @@ class gate(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:
         #
         # SPOT
         # createOrder/cancelOrder/fetchOrder/editOrder
@@ -4765,7 +4765,7 @@ class gate(Exchange, ImplicitAPI):
         fromId = self.convert_type_to_account(fromAccount)
         toId = self.convert_type_to_account(toAccount)
         truncated = self.currency_to_precision(code, amount)
-        request = {
+        request: dict = {
             'currency': currency['id'],  # todo: currencies have network-junctions
             'amount': truncated,
         }
@@ -4891,7 +4891,7 @@ class gate(Exchange, ImplicitAPI):
         #
         return response
 
-    def parse_position(self, position, market: Market = None):
+    def parse_position(self, position: dict, market: Market = None):
         #
         # swap and future
         #
@@ -5040,7 +5040,7 @@ class gate(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['contract']:
             raise BadRequest(self.id + ' fetchPosition() supports contract markets only')
-        request = {}
+        request: dict = {}
         request, params = self.prepare_request(market, market['type'], params)
         extendedRequest = self.extend(request, params)
         response = None
@@ -5128,7 +5128,7 @@ class gate(Exchange, ImplicitAPI):
             if symbolsLength > 0:
                 market = self.market(symbols[0])
         type = None
-        request = {}
+        request: dict = {}
         type, params = self.handle_market_type_and_params('fetchPositions', market, params)
         if (type is None) or (type == 'spot'):
             type = 'swap'  # default to swap
@@ -5208,7 +5208,7 @@ class gate(Exchange, ImplicitAPI):
         #
         return self.parse_positions(response, symbols)
 
-    def fetch_leverage_tiers(self, symbols: Strings = None, params={}):
+    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
         :see: https://www.gate.io/docs/developers/apiv4/en/#list-all-futures-contracts
@@ -5323,7 +5323,7 @@ class gate(Exchange, ImplicitAPI):
         #
         return self.parse_leverage_tiers(response, symbols, 'name')
 
-    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.gate.io/docs/developers/apiv4/en/#list-risk-limit-tiers
@@ -5377,7 +5377,7 @@ class gate(Exchange, ImplicitAPI):
             floor = cap
         return tiers
 
-    def parse_market_leverage_tiers(self, info, market: Market = None):
+    def parse_market_leverage_tiers(self, info, market: Market = None) -> List[LeverageTier]:
         #
         #     [
         #         {
@@ -5422,7 +5422,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
@@ -5449,7 +5449,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
@@ -5486,7 +5486,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
@@ -5529,7 +5529,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'].upper(),  # todo: currencies have network-junctions
             'amount': self.currency_to_precision(code, amount),
         }
@@ -5766,7 +5766,7 @@ class gate(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['swap']:
             raise BadRequest(self.id + ' fetchOpenInterest() supports swap markets only')
-        request = {
+        request: dict = {
             'contract': market['id'],
             'settle': market['settleId'],
             'interval': self.safe_string(self.timeframes, timeframe, timeframe),
@@ -5848,7 +5848,7 @@ class gate(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' fetchSettlementHistory() supports option markets only')
         marketId = market['id']
         optionParts = marketId.split('-')
-        request = {
+        request: dict = {
             'underlying': self.safe_string(optionParts, 0),
         }
         if since is not None:
@@ -5892,7 +5892,7 @@ class gate(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' fetchMySettlementHistory() supports option markets only')
         marketId = market['id']
         optionParts = marketId.split('-')
-        request = {
+        request: dict = {
             'underlying': self.safe_string(optionParts, 0),
             'contract': marketId,
         }
@@ -6019,7 +6019,7 @@ class gate(Exchange, ImplicitAPI):
         type = None
         currency = None
         response = None
-        request = {}
+        request: dict = {}
         type, params = self.handle_market_type_and_params('fetchLedger', None, params)
         if (type == 'spot') or (type == 'margin'):
             if code is not None:
@@ -6099,7 +6099,7 @@ class gate(Exchange, ImplicitAPI):
         #
         return self.parse_ledger(response, currency, since, limit)
 
-    def parse_ledger_entry(self, item, currency: Currency = None):
+    def parse_ledger_entry(self, item: dict, currency: Currency = None):
         #
         # spot
         #
@@ -6181,7 +6181,7 @@ class gate(Exchange, ImplicitAPI):
         }
 
     def parse_ledger_entry_type(self, type):
-        ledgerType = {
+        ledgerType: dict = {
             'deposit': 'deposit',
             'withdraw': 'withdrawal',
             'sub_account_transfer': 'transfer',
@@ -6286,7 +6286,7 @@ class gate(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['swap']:
             raise NotSupported(self.id + ' fetchLiquidations() supports swap markets only')
-        request = {
+        request: dict = {
             'settle': market['settleId'],
             'contract': market['id'],
         }
@@ -6326,7 +6326,7 @@ class gate(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchMyLiquidations() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'contract': market['id'],
         }
         response = None
@@ -6455,7 +6455,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'underlying': market['info']['underlying'],
         }
         response = self.publicOptionsGetTickers(self.extend(request, params))
@@ -6545,7 +6545,7 @@ class gate(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the okx api endpoint
         :returns dict[]: `A list of position structures <https://docs.ccxt.com/#/?id=position-structure>`
         """
-        request = {
+        request: dict = {
             'close': True,
         }
         params = self.extend(request, params)
@@ -6569,7 +6569,7 @@ class gate(Exchange, ImplicitAPI):
         if symbol is not None:
             # unified account does not require a symbol
             market = self.market(symbol)
-        request = {}
+        request: dict = {}
         response = None
         isUnified = self.safe_bool(params, 'unified')
         params = self.omit(params, 'unified')
@@ -6655,7 +6655,7 @@ class gate(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' fetchLeverage() does not support ' + market['type'] + ' markets')
         return self.parse_leverage(response, market)
 
-    def fetch_leverages(self, symbols: List[str] = None, params={}) -> Leverages:
+    def fetch_leverages(self, symbols: Strings = None, params={}) -> Leverages:
         """
         fetch the set leverage for all leverage markets, only spot margin is supported on gate
         :see: https://www.gate.io/docs/developers/apiv4/en/#list-lending-markets
@@ -6723,7 +6723,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'contract': market['id'],
         }
         response = self.publicOptionsGetContractsContract(self.extend(request, params))
@@ -6781,7 +6781,7 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'underlying': currency['code'] + '_USDT',  # todo: currency['id'].upper() &  network junctions
         }
         response = self.publicOptionsGetContracts(self.extend(request, params))
@@ -6920,7 +6920,7 @@ class gate(Exchange, ImplicitAPI):
         marketType, params = self.handle_market_type_and_params('fetchPositionsHistory', market, params, 'swap')
         until = self.safe_integer(params, 'until')
         params = self.omit(params, 'until')
-        request = {}
+        request: dict = {}
         request, params = self.prepare_request(market, marketType, params)
         if limit is not None:
             request['limit'] = limit