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

ccxt/coinlist.py

@@ -371,7 +371,7 @@ class coinlist(Exchange, ImplicitAPI):
         #     }
         #
         currencies = self.safe_value(response, 'assets', [])
-        result = {}
+        result: dict = {}
         for i in range(0, len(currencies)):
             currency = currencies[i]
             id = self.safe_string(currency, 'asset')
@@ -505,7 +505,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         tickers = self.publicGetV1SymbolsSummary(self.extend(request, params))
         #
         #     {
@@ -541,7 +541,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         ticker = self.publicGetV1SymbolsSymbolSummary(self.extend(request, params))
@@ -631,7 +631,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.publicGetV1SymbolsSymbolBook(self.extend(request, params))
@@ -672,7 +672,7 @@ class coinlist(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         granularity = self.safe_string(self.timeframes, timeframe)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'granularity': granularity,
         }
@@ -749,7 +749,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if since is not None:
@@ -788,7 +788,7 @@ class coinlist(Exchange, ImplicitAPI):
         auctions = self.safe_list(response, 'auctions', [])
         return self.parse_trades(auctions, market, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchTrades
         #     {
@@ -926,7 +926,7 @@ class coinlist(Exchange, ImplicitAPI):
         #     }
         #
         fees = self.safe_value(response, 'fees_by_symbols', {})
-        result = {}
+        result: dict = {}
         groupsOfSymbols = list(fees.keys())
         for i in range(0, len(groupsOfSymbols)):
             group = groupsOfSymbols[i]
@@ -939,7 +939,7 @@ class coinlist(Exchange, ImplicitAPI):
                 id = ids[j]
                 market = self.safe_market(id)
                 symbol = market['symbol']
-                info = {}
+                info: dict = {}
                 info[group] = feeTiers
                 result[symbol] = {
                     'info': info,
@@ -1096,7 +1096,7 @@ class coinlist(Exchange, ImplicitAPI):
         #         "net_liquidation_value_usd": "string"
         #     }
         #
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': None,
             'datetime': None,
@@ -1125,7 +1125,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         market = None
         if symbol is not None:
             market = self.market(symbol)
@@ -1181,7 +1181,7 @@ class coinlist(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
-        request = {
+        request: dict = {
             'order_id': id,
         }
         return self.fetch_my_trades(symbol, since, limit, self.extend(request, params))
@@ -1202,7 +1202,7 @@ class coinlist(Exchange, ImplicitAPI):
         status = self.safe_string(params, 'status')
         if status is None:
             status = ['accepted', 'done', 'canceled', 'rejected', 'pending']
-        request = {
+        request: dict = {
             'status': status,
         }
         market = None
@@ -1257,7 +1257,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'order_id': id,
         }
         response = self.privateGetV1OrdersOrderId(self.extend(request, params))
@@ -1299,7 +1299,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'status': 'accepted',
         }
         return self.fetch_orders(symbol, since, limit, self.extend(request, params))
@@ -1316,7 +1316,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'status': 'done',
         }
         return self.fetch_orders(symbol, since, limit, self.extend(request, params))
@@ -1333,7 +1333,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns dict: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'status': 'canceled',
         }
         return self.fetch_orders(symbol, since, limit, self.extend(request, params))
@@ -1348,7 +1348,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = None
-        request = {}
+        request: dict = {}
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
@@ -1372,7 +1372,7 @@ class coinlist(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'order_id': id,
         }
         response = self.privateDeleteV1OrdersOrderId(self.extend(request, params))
@@ -1416,7 +1416,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'type': type,
             'side': side,
@@ -1481,7 +1481,7 @@ class coinlist(Exchange, ImplicitAPI):
         if amount is None:
             raise ArgumentsRequired(self.id + ' editOrder() requires an amount argument')
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'order_id': id,
             'type': type,
             'side': side,
@@ -1492,7 +1492,7 @@ class coinlist(Exchange, ImplicitAPI):
         response = self.privatePatchV1OrdersOrderId(self.extend(request, params))
         return self.parse_order(response, market)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # fetchOrder
         #     {
@@ -1616,8 +1616,8 @@ class coinlist(Exchange, ImplicitAPI):
             'postOnly': postOnly,
         }, market)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'pending': 'open',
             'accepted': 'open',
             'rejected': 'rejected',
@@ -1627,7 +1627,7 @@ class coinlist(Exchange, ImplicitAPI):
         return self.safe_string(statuses, status, status)
 
     def parse_order_type(self, status):
-        statuses = {
+        statuses: dict = {
             'market': 'market',
             'limit': 'limit',
             'stop_market': 'market',
@@ -1652,7 +1652,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'asset': currency['id'],
             'amount': self.currency_to_precision(code, amount),
         }
@@ -1700,7 +1700,7 @@ class coinlist(Exchange, ImplicitAPI):
         currency = None
         if code is not None:
             currency = self.currency(code)
-        request = {}
+        request: dict = {}
         if since is not None:
             request['start_time'] = self.iso8601(since)
         if limit is not None:
@@ -1791,7 +1791,7 @@ class coinlist(Exchange, ImplicitAPI):
         }
 
     def parse_transfer_status(self, status: Str) -> Str:
-        statuses = {
+        statuses: dict = {
             'confirmed': 'ok',
         }
         return self.safe_string(statuses, status, status)
@@ -1813,7 +1813,7 @@ class coinlist(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchDepositsWithdrawals() requires a traderId argument in the params')
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'asset': currency['id'],
             'trader_id': traderId,
         }
@@ -1881,7 +1881,7 @@ class coinlist(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'asset': currency['id'],
             'amount': self.currency_to_precision(code, amount),
             'destination_address': address,
@@ -1895,7 +1895,7 @@ class coinlist(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:
         # withdraw
         #
         #     {
@@ -1955,7 +1955,7 @@ class coinlist(Exchange, ImplicitAPI):
         }
 
     def parse_transaction_type(self, type):
-        types = {
+        types: dict = {
             'CRYPTO_DEPOSIT': 'deposit',
             'CRYPTO_WITHDRAWAL': 'withdrawal',
             'PRO_TRANSFER': 'transfer',
@@ -1977,7 +1977,7 @@ class coinlist(Exchange, ImplicitAPI):
         if traderId is None:
             raise ArgumentsRequired(self.id + ' fetchLedger() requires a traderId argument in the params')
         self.load_markets()
-        request = {
+        request: dict = {
             'trader_id': traderId,
         }
         currency = None
@@ -2061,7 +2061,7 @@ class coinlist(Exchange, ImplicitAPI):
         ledger = self.safe_value(response, 'transactions', [])
         return self.parse_ledger(ledger, currency, since, limit)
 
-    def parse_ledger_entry(self, item, currency: Currency = None):
+    def parse_ledger_entry(self, item: dict, currency: Currency = None):
         #
         # deposit transaction from wallet(funding) to pro(trading)
         #     {
@@ -2165,7 +2165,7 @@ class coinlist(Exchange, ImplicitAPI):
         }
 
     def parse_ledger_entry_type(self, type):
-        types = {
+        types: dict = {
             'atomic token swap': 'trade',
             'fee': 'fee',
             'deposit': 'transfer',

ccxt/coinmate.py

@@ -323,7 +323,7 @@ class coinmate(Exchange, ImplicitAPI):
 
     def parse_balance(self, response) -> Balances:
         balances = self.safe_value(response, 'data', {})
-        result = {'info': response}
+        result: dict = {'info': response}
         currencyIds = list(balances.keys())
         for i in range(0, len(currencyIds)):
             currencyId = currencyIds[i]
@@ -358,7 +358,7 @@ class coinmate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currencyPair': market['id'],
             'groupByPriceLimit': 'False',
         }
@@ -377,7 +377,7 @@ class coinmate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currencyPair': market['id'],
         }
         response = self.publicGetTicker(self.extend(request, params))
@@ -433,7 +433,7 @@ class coinmate(Exchange, ImplicitAPI):
         #
         data = self.safe_value(response, 'data', {})
         keys = list(data.keys())
-        result = {}
+        result: dict = {}
         for i in range(0, len(keys)):
             market = self.market(keys[i])
             ticker = self.parse_ticker(self.safe_value(data, keys[i]), market)
@@ -490,7 +490,7 @@ class coinmate(Exchange, ImplicitAPI):
         :returns dict: a list of `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'limit': 1000,
         }
         if limit is not None:
@@ -505,7 +505,7 @@ class coinmate(Exchange, ImplicitAPI):
         return self.parse_transactions(items, None, since, limit)
 
     def parse_transaction_status(self, status):
-        statuses = {
+        statuses: dict = {
             'COMPLETED': 'ok',
             'WAITING': 'pending',
             'SENT': 'pending',
@@ -516,7 +516,7 @@ class coinmate(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:
         #
         # deposits
         #
@@ -613,7 +613,7 @@ class coinmate(Exchange, ImplicitAPI):
         if method is None:
             allowedCurrencies = list(methods.keys())
             raise ExchangeError(self.id + ' withdraw() only allows withdrawing the following currencies: ' + ', '.join(allowedCurrencies))
-        request = {
+        request: dict = {
             'amount': self.currency_to_precision(code, amount),
             'address': address,
         }
@@ -654,7 +654,7 @@ class coinmate(Exchange, ImplicitAPI):
         self.load_markets()
         if limit is None:
             limit = 1000
-        request = {
+        request: dict = {
             'limit': limit,
         }
         if symbol is not None:
@@ -666,7 +666,7 @@ class coinmate(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_trades(data, None, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchMyTrades(private)
         #
@@ -740,7 +740,7 @@ class coinmate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currencyPair': market['id'],
             'minutesIntoHistory': 10,
         }
@@ -774,7 +774,7 @@ class coinmate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currencyPair': market['id'],
         }
         response = self.privatePostTraderFees(self.extend(request, params))
@@ -810,7 +810,7 @@ class coinmate(Exchange, ImplicitAPI):
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         response = self.privatePostOpenOrders(self.extend({}, params))
-        extension = {'status': 'open'}
+        extension: dict = {'status': 'open'}
         return self.parse_orders(response['data'], None, since, limit, extension)
 
     def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -827,7 +827,7 @@ class coinmate(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchOrders() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currencyPair': market['id'],
         }
         # offset param that appears in other parts of the API doesn't appear to be supported here
@@ -836,8 +836,8 @@ class coinmate(Exchange, ImplicitAPI):
         response = self.privatePostOrderHistory(self.extend(request, params))
         return self.parse_orders(response['data'], market, since, limit)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'FILLED': 'closed',
             'CANCELLED': 'canceled',
             'PARTIALLY_FILLED': 'open',
@@ -845,14 +845,14 @@ class coinmate(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_order_type(self, type):
-        types = {
+    def parse_order_type(self, type: Str):
+        types: dict = {
             'LIMIT': 'limit',
             'MARKET': 'market',
         }
         return self.safe_string(types, type, type)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # limit sell
         #
@@ -951,7 +951,7 @@ class coinmate(Exchange, ImplicitAPI):
         self.load_markets()
         method = 'privatePost' + self.capitalize(side)
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currencyPair': market['id'],
         }
         if type == 'market':
@@ -981,7 +981,7 @@ class coinmate(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'orderId': id,
         }
         market = None
@@ -1001,7 +1001,7 @@ class coinmate(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         #   {"error":false,"errorMessage":null,"data":{"success":true,"remainingAmount":0.01}}
-        request = {'orderId': id}
+        request: dict = {'orderId': id}
         response = self.privatePostCancelOrderWithInfo(self.extend(request, params))
         return {
             'info': response,

ccxt/coinmetro.py

@@ -308,7 +308,7 @@ class coinmetro(Exchange, ImplicitAPI):
         #         ...
         #     ]
         #
-        result = {}
+        result: dict = {}
         for i in range(0, len(response)):
             currency = response[i]
             id = self.safe_string(currency, 'symbol')
@@ -455,7 +455,7 @@ class coinmetro(Exchange, ImplicitAPI):
                         baseId = restId
                         quoteId = currencyId
                     break
-        result = {
+        result: dict = {
             'baseId': baseId,
             'quoteId': quoteId,
         }
@@ -468,7 +468,7 @@ class coinmetro(Exchange, ImplicitAPI):
         limits = self.safe_value(currency, 'limits', {})
         amountLimits = self.safe_value(limits, 'amount', {})
         minLimit = self.safe_number(amountLimits, 'min')
-        result = {
+        result: dict = {
             'precision': precision,
             'minLimit': minLimit,
         }
@@ -488,7 +488,7 @@ class coinmetro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
             'timeframe': self.safe_string(self.timeframes, timeframe, timeframe),
         }
@@ -559,7 +559,7 @@ class coinmetro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         if since is not None:
@@ -613,7 +613,7 @@ class coinmetro(Exchange, ImplicitAPI):
         market = None
         if symbol is not None:
             market = self.market(symbol)
-        request = {}
+        request: dict = {}
         if since is not None:
             request['since'] = since
         else:
@@ -636,7 +636,7 @@ class coinmetro(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:
         #
         # fetchTrades
         #     {
@@ -715,7 +715,7 @@ class coinmetro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         response = self.publicGetExchangeBookPair(self.extend(request, params))
@@ -749,7 +749,7 @@ class coinmetro(Exchange, ImplicitAPI):
         book = self.safe_value(response, 'book', {})
         rawBids = self.safe_value(book, 'bid', {})
         rawAsks = self.safe_value(book, 'ask', {})
-        rawOrderbook = {
+        rawOrderbook: dict = {
             'bids': rawBids,
             'asks': rawAsks,
         }
@@ -827,7 +827,7 @@ class coinmetro(Exchange, ImplicitAPI):
         #
         latestPrices = self.safe_value(response, 'latestPrices', [])
         twentyFourHInfos = self.safe_value(response, '24hInfo', [])
-        tickersObject = {}
+        tickersObject: dict = {}
         # merging info from two lists into one
         for i in range(0, len(latestPrices)):
             latestPrice = latestPrices[i]
@@ -944,7 +944,7 @@ class coinmetro(Exchange, ImplicitAPI):
         #         ...
         #     ]
         #
-        result = {
+        result: dict = {
             'info': balances,
         }
         for i in range(0, len(balances)):
@@ -969,7 +969,7 @@ class coinmetro(Exchange, ImplicitAPI):
         :returns dict: a `ledger structure <https://docs.ccxt.com/#/?id=ledger-structure>`
         """
         self.load_markets()
-        request = {}
+        request: dict = {}
         if since is not None:
             request['since'] = since
         else:
@@ -1079,7 +1079,7 @@ class coinmetro(Exchange, ImplicitAPI):
                 ledger.append(rawLedgerEntry)
         return self.parse_ledger(ledger, currency, since, limit)
 
-    def parse_ledger_entry(self, item, currency: Currency = None):
+    def parse_ledger_entry(self, item: dict, currency: Currency = None):
         datetime = self.safe_string(item, 'timestamp')
         currencyId = self.safe_string(item, 'currencyId')
         item = self.omit(item, 'currencyId')
@@ -1134,7 +1134,7 @@ class coinmetro(Exchange, ImplicitAPI):
         return [type, referenceId]
 
     def parse_ledger_entry_type(self, type):
-        types = {
+        types: dict = {
             'Deposit': 'transaction',
             'Withdraw': 'transaction',
             'Order': 'trade',
@@ -1164,7 +1164,7 @@ class coinmetro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
         }
         request['orderType'] = type
         precisedAmount = None
@@ -1249,7 +1249,7 @@ class coinmetro(Exchange, ImplicitAPI):
         return request
 
     def encode_order_time_in_force(self, timeInForce):
-        timeInForceTypes = {
+        timeInForceTypes: dict = {
             'GTC': 1,
             'IOC': 2,
             'GTD': 3,
@@ -1269,7 +1269,7 @@ class coinmetro(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'orderID': id,
         }
         marginMode = None
@@ -1317,7 +1317,7 @@ class coinmetro(Exchange, ImplicitAPI):
         orderId = self.safe_string(params, 'orderId')
         if orderId is None:
             raise ArgumentsRequired(self.id + ' closePosition() requires a orderId parameter')
-        request = {
+        request: dict = {
             'orderID': orderId,
         }
         response = self.privatePostExchangeOrdersCloseOrderID(self.extend(request, params))
@@ -1387,7 +1387,7 @@ class coinmetro(Exchange, ImplicitAPI):
         market = None
         if symbol is not None:
             market = self.market(symbol)
-        request = {}
+        request: dict = {}
         if since is not None:
             request['since'] = since
         response = self.privateGetExchangeOrdersHistorySince(self.extend(request, params))
@@ -1403,7 +1403,7 @@ class coinmetro(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'orderID': id,
         }
         response = self.privateGetExchangeOrdersStatusOrderID(self.extend(request, params))
@@ -1444,7 +1444,7 @@ class coinmetro(Exchange, ImplicitAPI):
         #
         return self.parse_order(response)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # createOrder market
         #     {
@@ -1735,7 +1735,7 @@ class coinmetro(Exchange, ImplicitAPI):
         self.load_markets()
         currency = self.currency(code)
         currencyId = currency['id']
-        request = {}
+        request: dict = {}
         request[currencyId] = self.currency_to_precision(code, amount)
         response = self.privatePutUsersMarginCollateral(self.extend(request, params))
         #