ccxt 4.4.27__py2.py3-none-any.whl → 4.4.29__py2.py3-none-any.whl

ccxt/bitopro.py

@@ -233,7 +233,7 @@ class bitopro(Exchange, ImplicitAPI):
         :returns dict: an associative dictionary of currencies
         """
         response = self.publicGetProvisioningCurrencies(params)
-        currencies = self.safe_value(response, 'data', [])
+        currencies = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -255,8 +255,8 @@ class bitopro(Exchange, ImplicitAPI):
             currency = currencies[i]
             currencyId = self.safe_string(currency, 'currency')
             code = self.safe_currency_code(currencyId)
-            deposit = self.safe_value(currency, 'deposit')
-            withdraw = self.safe_value(currency, 'withdraw')
+            deposit = self.safe_bool(currency, 'deposit')
+            withdraw = self.safe_bool(currency, 'withdraw')
             fee = self.safe_number(currency, 'withdrawFee')
             withdrawMin = self.safe_number(currency, 'minWithdraw')
             withdrawMax = self.safe_number(currency, 'maxWithdraw')
@@ -293,7 +293,7 @@ class bitopro(Exchange, ImplicitAPI):
         :returns dict[]: an array of objects representing market data
         """
         response = self.publicGetProvisioningTradingPairs()
-        markets = self.safe_value(response, 'data', [])
+        markets = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -317,7 +317,7 @@ class bitopro(Exchange, ImplicitAPI):
         return self.parse_markets(markets)
 
     def parse_market(self, market: dict) -> Market:
-        active = not self.safe_value(market, 'maintain')
+        active = not self.safe_bool(market, 'maintain')
         id = self.safe_string(market, 'pair')
         uppercaseId = id.upper()
         baseId = self.safe_string(market, 'base')
@@ -429,7 +429,7 @@ class bitopro(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         response = self.publicGetTickersPair(self.extend(request, params))
-        ticker = self.safe_value(response, 'data', {})
+        ticker = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{
@@ -455,7 +455,7 @@ class bitopro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         response = self.publicGetTickers()
-        tickers = self.safe_value(response, 'data', [])
+        tickers = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -551,7 +551,7 @@ class bitopro(Exchange, ImplicitAPI):
         type = self.safe_string_lower(trade, 'type')
         side = self.safe_string_lower(trade, 'action')
         if side is None:
-            isBuyer = self.safe_value(trade, 'isBuyer')
+            isBuyer = self.safe_bool(trade, 'isBuyer')
             if isBuyer:
                 side = 'buy'
             else:
@@ -568,7 +568,7 @@ class bitopro(Exchange, ImplicitAPI):
                 'currency': feeSymbol,
                 'rate': None,
             }
-        isTaker = self.safe_value(trade, 'isTaker')
+        isTaker = self.safe_bool(trade, 'isTaker')
         takerOrMaker = None
         if isTaker is not None:
             if isTaker:
@@ -607,7 +607,7 @@ class bitopro(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         response = self.publicGetTradesPair(self.extend(request, params))
-        trades = self.safe_value(response, 'data', [])
+        trades = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -631,7 +631,7 @@ class bitopro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         response = self.publicGetProvisioningLimitationsAndFees(params)
-        tradingFeeRate = self.safe_value(response, 'tradingFeeRate', {})
+        tradingFeeRate = self.safe_dict(response, 'tradingFeeRate', {})
         first = self.safe_value(tradingFeeRate, 0)
         #
         #     {
@@ -753,7 +753,7 @@ class bitopro(Exchange, ImplicitAPI):
             request['from'] = int(math.floor(since / 1000))
             request['to'] = self.sum(request['from'], limit * timeframeInSeconds)
         response = self.publicGetTradingHistoryPair(self.extend(request, params))
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -841,7 +841,7 @@ class bitopro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         response = self.privateGetAccountsBalance(params)
-        balances = self.safe_value(response, 'data', [])
+        balances = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1101,7 +1101,7 @@ class bitopro(Exchange, ImplicitAPI):
             response = self.privateDeleteOrdersPair(self.extend(request, params))
         else:
             response = self.privateDeleteOrdersAll(self.extend(request, params))
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{
@@ -1183,7 +1183,7 @@ class bitopro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit
         response = self.privateGetOrdersAllPair(self.extend(request, params))
-        orders = self.safe_value(response, 'data')
+        orders = self.safe_list(response, 'data', [])
         if orders is None:
             orders = []
         #
@@ -1253,7 +1253,7 @@ class bitopro(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         response = self.privateGetOrdersTradesPair(self.extend(request, params))
-        trades = self.safe_value(response, 'data', [])
+        trades = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1395,7 +1395,7 @@ class bitopro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit
         response = self.privateGetWalletDepositHistoryCurrency(self.extend(request, params))
-        result = self.safe_value(response, 'data', [])
+        result = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1442,7 +1442,7 @@ class bitopro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit
         response = self.privateGetWalletWithdrawHistoryCurrency(self.extend(request, params))
-        result = self.safe_value(response, 'data', [])
+        result = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1481,7 +1481,7 @@ class bitopro(Exchange, ImplicitAPI):
             'currency': currency['id'],
         }
         response = self.privateGetWalletWithdrawCurrencySerial(self.extend(request, params))
-        result = self.safe_value(response, 'data', {})
+        result = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{
@@ -1500,7 +1500,7 @@ class bitopro(Exchange, ImplicitAPI):
         #
         return self.parse_transaction(result, currency)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://github.com/bitoex/bitopro-offical-api-docs/blob/master/api/v3/private/create_an_withdraw_invoice.md
@@ -1521,7 +1521,7 @@ class bitopro(Exchange, ImplicitAPI):
             'address': address,
         }
         if 'network' in params:
-            networks = self.safe_value(self.options, 'networks', {})
+            networks = self.safe_dict(self.options, 'networks', {})
             requestedNetwork = self.safe_string_upper(params, 'network')
             params = self.omit(params, ['network'])
             networkId = self.safe_string(networks, requestedNetwork)
@@ -1531,7 +1531,7 @@ class bitopro(Exchange, ImplicitAPI):
         if tag is not None:
             request['message'] = tag
         response = self.privatePostWalletWithdrawCurrency(self.extend(request, params))
-        result = self.safe_value(response, 'data', {})
+        result = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{

ccxt/bitrue.py

@@ -633,7 +633,7 @@ class bitrue(Exchange, ImplicitAPI):
         #     }
         #
         result: dict = {}
-        coins = self.safe_value(response, 'coins', [])
+        coins = self.safe_list(response, 'coins', [])
         for i in range(0, len(coins)):
             currency = coins[i]
             id = self.safe_string(currency, 'coin')
@@ -644,15 +644,15 @@ class bitrue(Exchange, ImplicitAPI):
             minWithdrawString = None
             maxWithdrawString = None
             minWithdrawFeeString = None
-            networkDetails = self.safe_value(currency, 'chainDetail', [])
+            networkDetails = self.safe_list(currency, 'chainDetail', [])
             networks: dict = {}
             for j in range(0, len(networkDetails)):
                 entry = networkDetails[j]
                 networkId = self.safe_string(entry, 'chain')
                 network = self.network_id_to_code(networkId, code)
-                enableDeposit = self.safe_value(entry, 'enableDeposit')
+                enableDeposit = self.safe_bool(entry, 'enableDeposit')
                 deposit = enableDeposit if (enableDeposit) else deposit
-                enableWithdraw = self.safe_value(entry, 'enableWithdraw')
+                enableWithdraw = self.safe_bool(entry, 'enableWithdraw')
                 withdraw = enableWithdraw if (enableWithdraw) else withdraw
                 networkWithdrawFeeString = self.safe_string(entry, 'withdrawFee')
                 if networkWithdrawFeeString is not None:
@@ -828,11 +828,11 @@ class bitrue(Exchange, ImplicitAPI):
         symbol = base + '/' + quote
         if settle is not None:
             symbol += ':' + settle
-        filters = self.safe_value(market, 'filters', [])
+        filters = self.safe_list(market, 'filters', [])
         filtersByType = self.index_by(filters, 'filterType')
         status = self.safe_string(market, 'status')
-        priceFilter = self.safe_value(filtersByType, 'PRICE_FILTER', {})
-        amountFilter = self.safe_value(filtersByType, 'LOT_SIZE', {})
+        priceFilter = self.safe_dict(filtersByType, 'PRICE_FILTER', {})
+        amountFilter = self.safe_dict(filtersByType, 'LOT_SIZE', {})
         defaultPricePrecision = self.safe_string(market, 'pricePrecision')
         defaultAmountPrecision = self.safe_string(market, 'quantityPrecision')
         pricePrecision = self.safe_string(priceFilter, 'priceScale', defaultPricePrecision)
@@ -980,7 +980,7 @@ class bitrue(Exchange, ImplicitAPI):
         if type == 'swap':
             if subType is not None and subType == 'inverse':
                 response = self.dapiV2PrivateGetAccount(params)
-                result = self.safe_value(response, 'data', {})
+                result = self.safe_dict(response, 'data', {})
                 #
                 # {
                 #         "code":"0",
@@ -1013,7 +1013,7 @@ class bitrue(Exchange, ImplicitAPI):
                 #
             else:
                 response = self.fapiV2PrivateGetAccount(params)
-                result = self.safe_value(response, 'data', {})
+                result = self.safe_dict(response, 'data', {})
                 #
                 #     {
                 #         "code":"0",
@@ -1228,7 +1228,7 @@ class bitrue(Exchange, ImplicitAPI):
                 'symbol': market['id'],
             }
             response = self.spotV1PublicGetTicker24hr(self.extend(request, params))
-            data = self.safe_value(response, 0, {})
+            data = self.safe_dict(response, 0, {})
         else:
             raise NotSupported(self.id + ' fetchTicker only support spot & swap markets')
         #
@@ -1286,11 +1286,11 @@ class bitrue(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        timeframes = self.safe_value(self.options, 'timeframes', {})
+        timeframes = self.safe_dict(self.options, 'timeframes', {})
         response = None
         data = None
         if market['swap']:
-            timeframesFuture = self.safe_value(timeframes, 'future', {})
+            timeframesFuture = self.safe_dict(timeframes, 'future', {})
             request: dict = {
                 'contractName': market['id'],
                 # 1min / 5min / 15min / 30min / 1h / 1day / 1week / 1month
@@ -1304,7 +1304,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.dapiV1PublicGetKlines(self.extend(request, params))
             data = response
         elif market['spot']:
-            timeframesSpot = self.safe_value(timeframes, 'spot', {})
+            timeframesSpot = self.safe_dict(timeframes, 'spot', {})
             request: dict = {
                 'symbol': market['id'],
                 # 1m / 5m / 15m / 30m / 1H / 2H / 4H / 12H / 1D / 1W
@@ -1315,7 +1315,7 @@ class bitrue(Exchange, ImplicitAPI):
             if since is not None:
                 request['fromIdx'] = since
             response = self.spotV1PublicGetMarketKline(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         else:
             raise NotSupported(self.id + ' fetchOHLCV only support spot & swap markets')
         #
@@ -1522,7 +1522,7 @@ class bitrue(Exchange, ImplicitAPI):
         # https://github.com/ccxt/ccxt/issues/13856
         tickers: dict = {}
         for i in range(0, len(data)):
-            ticker = self.safe_value(data, i, {})
+            ticker = self.safe_dict(data, i, {})
             market = self.market(self.safe_value(ticker, 'symbol'))
             tickers[market['id']] = ticker
         return self.parse_tickers(tickers, symbols)
@@ -1584,8 +1584,8 @@ class bitrue(Exchange, ImplicitAPI):
         orderId = self.safe_string(trade, 'orderId')
         id = self.safe_string_2(trade, 'id', 'tradeId')
         side = None
-        buyerMaker = self.safe_value(trade, 'isBuyerMaker')  # ignore "m" until Bitrue fixes api
-        isBuyer = self.safe_value(trade, 'isBuyer')
+        buyerMaker = self.safe_bool(trade, 'isBuyerMaker')  # ignore "m" until Bitrue fixes api
+        isBuyer = self.safe_bool(trade, 'isBuyer')
         if buyerMaker is not None:
             side = 'sell' if buyerMaker else 'buy'
         if isBuyer is not None:
@@ -1597,7 +1597,7 @@ class bitrue(Exchange, ImplicitAPI):
                 'currency': self.safe_currency_code(self.safe_string(trade, 'commissionAssert')),
             }
         takerOrMaker = None
-        isMaker = self.safe_value(trade, 'isMaker')
+        isMaker = self.safe_bool(trade, 'isMaker')
         if isMaker is not None:
             takerOrMaker = 'maker' if isMaker else 'taker'
         return self.safe_trade({
@@ -1750,7 +1750,7 @@ class bitrue(Exchange, ImplicitAPI):
         id = self.safe_string(order, 'orderId')
         type = self.safe_string_lower(order, 'type')
         side = self.safe_string_lower(order, 'side')
-        fills = self.safe_value(order, 'fills', [])
+        fills = self.safe_list(order, 'fills', [])
         clientOrderId = self.safe_string(order, 'clientOrderId')
         timeInForce = self.safe_string(order, 'timeInForce')
         postOnly = (type == 'limit_maker') or (timeInForce == 'GTX') or (type == 'post_only')
@@ -1880,7 +1880,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.fapiV2PrivatePostOrder(self.extend(request, params))
             elif market['inverse']:
                 response = self.dapiV2PrivatePostOrder(self.extend(request, params))
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
         elif market['spot']:
             request['symbol'] = market['id']
             request['quantity'] = self.amount_to_precision(symbol, amount)
@@ -1955,7 +1955,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.fapiV2PrivateGetOrder(self.extend(request, params))
             elif market['inverse']:
                 response = self.dapiV2PrivateGetOrder(self.extend(request, params))
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
         elif market['spot']:
             request['orderId'] = id  # spot market id is mandatory
             request['symbol'] = market['id']
@@ -2085,7 +2085,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.fapiV2PrivateGetOpenOrders(self.extend(request, params))
             elif market['inverse']:
                 response = self.dapiV2PrivateGetOpenOrders(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         elif market['spot']:
             request['symbol'] = market['id']
             response = self.spotV1PrivateGetOpenOrders(self.extend(request, params))
@@ -2173,7 +2173,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.fapiV2PrivatePostCancel(self.extend(request, params))
             elif market['inverse']:
                 response = self.dapiV2PrivatePostCancel(self.extend(request, params))
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
         elif market['spot']:
             request['symbol'] = market['id']
             response = self.spotV1PrivateDeleteOrder(self.extend(request, params))
@@ -2224,7 +2224,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.fapiV2PrivatePostAllOpenOrders(self.extend(request, params))
             elif market['inverse']:
                 response = self.dapiV2PrivatePostAllOpenOrders(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         else:
             raise NotSupported(self.id + ' cancelAllOrders only support future markets')
         #
@@ -2269,7 +2269,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = self.fapiV2PrivateGetMyTrades(self.extend(request, params))
             elif market['inverse']:
                 response = self.dapiV2PrivateGetMyTrades(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         elif market['spot']:
             request['symbol'] = market['id']
             response = self.spotV2PrivateGetMyTrades(self.extend(request, params))
@@ -2456,7 +2456,7 @@ class bitrue(Exchange, ImplicitAPI):
                 '6': 'canceled',
             },
         }
-        statuses = self.safe_value(statusesByType, type, {})
+        statuses = self.safe_dict(statusesByType, type, {})
         return self.safe_string(statuses, status, status)
 
     def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
@@ -2579,7 +2579,7 @@ class bitrue(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#withdraw-commit--withdraw_data
@@ -2637,7 +2637,7 @@ class bitrue(Exchange, ImplicitAPI):
         #       "chainDetail": [[Object]]
         #   }
         #
-        chainDetails = self.safe_value(fee, 'chainDetail', [])
+        chainDetails = self.safe_list(fee, 'chainDetail', [])
         chainDetailLength = len(chainDetails)
         result: dict = {
             'info': fee,
@@ -2778,7 +2778,7 @@ class bitrue(Exchange, ImplicitAPI):
         """
         self.load_markets()
         currency = self.currency(code)
-        accountTypes = self.safe_value(self.options, 'accountsByType', {})
+        accountTypes = self.safe_dict(self.options, 'accountsByType', {})
         fromId = self.safe_string(accountTypes, fromAccount, fromAccount)
         toId = self.safe_string(accountTypes, toAccount, toAccount)
         request: dict = {

ccxt/bitso.py

@@ -1500,7 +1500,7 @@ class bitso(Exchange, ImplicitAPI):
                 result[code]['info'][code] = withdrawFee
         return result
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/bitstamp.py

@@ -2009,7 +2009,7 @@ class bitstamp(Exchange, ImplicitAPI):
             'tag': tag,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://www.bitstamp.net/api/#tag/Withdrawals/operation/RequestFiatWithdrawal

ccxt/bitvavo.py

@@ -1081,6 +1081,9 @@ class bitvavo(Exchange, ImplicitAPI):
             request['timeInForce'] = timeInForce
         if postOnly:
             request['postOnly'] = True
+        clientOrderId = self.safe_string(params, 'clientOrderId')
+        if clientOrderId is None:
+            request['clientOrderId'] = self.uuid22()
         return self.extend(request, params)
 
     def create_order(self, symbol: Str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -1631,7 +1634,7 @@ class bitvavo(Exchange, ImplicitAPI):
             request['paymentId'] = tag
         return self.extend(request, params)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/blockchaincom.py

@@ -880,7 +880,7 @@ class blockchaincom(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://api.blockchain.com/v3/#createwithdrawal

ccxt/btcmarkets.py

@@ -1131,7 +1131,7 @@ class btcmarkets(Exchange, ImplicitAPI):
         #
         return self.parse_trades(response, market, since, limit)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.btcmarkets.net/v3/#tag/Fund-Management-APIs/paths/~1v3~1withdrawals/post