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

ccxt/async_support/bitrue.py

@@ -634,7 +634,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')
@@ -645,15 +645,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:
@@ -829,11 +829,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)
@@ -981,7 +981,7 @@ class bitrue(Exchange, ImplicitAPI):
         if type == 'swap':
             if subType is not None and subType == 'inverse':
                 response = await self.dapiV2PrivateGetAccount(params)
-                result = self.safe_value(response, 'data', {})
+                result = self.safe_dict(response, 'data', {})
                 #
                 # {
                 #         "code":"0",
@@ -1014,7 +1014,7 @@ class bitrue(Exchange, ImplicitAPI):
                 #
             else:
                 response = await self.fapiV2PrivateGetAccount(params)
-                result = self.safe_value(response, 'data', {})
+                result = self.safe_dict(response, 'data', {})
                 #
                 #     {
                 #         "code":"0",
@@ -1229,7 +1229,7 @@ class bitrue(Exchange, ImplicitAPI):
                 'symbol': market['id'],
             }
             response = await 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')
         #
@@ -1287,11 +1287,11 @@ class bitrue(Exchange, ImplicitAPI):
         """
         await 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
@@ -1305,7 +1305,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await 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
@@ -1316,7 +1316,7 @@ class bitrue(Exchange, ImplicitAPI):
             if since is not None:
                 request['fromIdx'] = since
             response = await 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')
         #
@@ -1523,7 +1523,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)
@@ -1585,8 +1585,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:
@@ -1598,7 +1598,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({
@@ -1751,7 +1751,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')
@@ -1881,7 +1881,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivatePostOrder(self.extend(request, params))
             elif market['inverse']:
                 response = await 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)
@@ -1956,7 +1956,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivateGetOrder(self.extend(request, params))
             elif market['inverse']:
                 response = await 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']
@@ -2086,7 +2086,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivateGetOpenOrders(self.extend(request, params))
             elif market['inverse']:
                 response = await 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 = await self.spotV1PrivateGetOpenOrders(self.extend(request, params))
@@ -2174,7 +2174,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivatePostCancel(self.extend(request, params))
             elif market['inverse']:
                 response = await 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 = await self.spotV1PrivateDeleteOrder(self.extend(request, params))
@@ -2225,7 +2225,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivatePostAllOpenOrders(self.extend(request, params))
             elif market['inverse']:
                 response = await 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')
         #
@@ -2270,7 +2270,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivateGetMyTrades(self.extend(request, params))
             elif market['inverse']:
                 response = await 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 = await self.spotV2PrivateGetMyTrades(self.extend(request, params))
@@ -2457,7 +2457,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:
@@ -2580,7 +2580,7 @@ class bitrue(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async 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
@@ -2638,7 +2638,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,
@@ -2779,7 +2779,7 @@ class bitrue(Exchange, ImplicitAPI):
         """
         await 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/async_support/bitso.py

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

ccxt/async_support/bitstamp.py

@@ -2009,7 +2009,7 @@ class bitstamp(Exchange, ImplicitAPI):
             'tag': tag,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async 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/async_support/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)
 
     async 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)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/async_support/blockchaincom.py

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

ccxt/async_support/btcmarkets.py

@@ -1131,7 +1131,7 @@ class btcmarkets(Exchange, ImplicitAPI):
         #
         return self.parse_trades(response, market, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async 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