ccxt 4.2.29__py2.py3-none-any.whl → 4.2.31__py2.py3-none-any.whl

ccxt/async_support/woo.py

@@ -1065,7 +1065,7 @@ class woo(Exchange, ImplicitAPI):
         :param boolean [params.stop]: whether the order is a stop/algo order
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        stop = self.safe_value(params, 'stop', False)
+        stop = self.safe_bool(params, 'stop', False)
         params = self.omit(params, 'stop')
         if not stop and (symbol is None):
             raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument')
@@ -1214,7 +1214,7 @@ class woo(Exchange, ImplicitAPI):
         request = {}
         market: Market = None
         stop = self.safe_value(params, 'stop')
-        trailing = self.safe_value(params, 'trailing', False)
+        trailing = self.safe_bool(params, 'trailing', False)
         params = self.omit(params, ['stop', 'trailing'])
         if symbol is not None:
             market = self.market(symbol)
@@ -1947,7 +1947,7 @@ class woo(Exchange, ImplicitAPI):
         #
         transfer = self.parse_transfer(response, currency)
         transferOptions = self.safe_value(self.options, 'transfer', {})
-        fillResponseFromRequest = self.safe_value(transferOptions, 'fillResponseFromRequest', True)
+        fillResponseFromRequest = self.safe_bool(transferOptions, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
             transfer['amount'] = amount
             transfer['fromAccount'] = fromAccount

ccxt/async_support/yobit.py

@@ -1224,7 +1224,7 @@ class yobit(Exchange, ImplicitAPI):
             #
             # To cover points 1, 2, 3 and 4 combined self handler should work like self:
             #
-            success = self.safe_value(response, 'success', False)
+            success = self.safe_bool(response, 'success', False)
             if isinstance(success, str):
                 if (success == 'true') or (success == '1'):
                     success = True

ccxt/async_support/zaif.py

@@ -691,7 +691,7 @@ class zaif(Exchange, ImplicitAPI):
             self.throw_exactly_matched_exception(self.exceptions['exact'], error, feedback)
             self.throw_broadly_matched_exception(self.exceptions['broad'], error, feedback)
             raise ExchangeError(feedback)  # unknown message
-        success = self.safe_value(response, 'success', True)
+        success = self.safe_bool(response, 'success', True)
         if not success:
             raise ExchangeError(feedback)
         return None

ccxt/async_support/zonda.py

@@ -1399,7 +1399,7 @@ class zonda(Exchange, ImplicitAPI):
         #     }
         #
         id = self.safe_string_2(response, 'offerId', 'stopOfferId')
-        completed = self.safe_value(response, 'completed', False)
+        completed = self.safe_bool(response, 'completed', False)
         status = 'closed' if completed else 'open'
         transactions = self.safe_value(response, 'transactions')
         return self.safe_order({
@@ -1457,7 +1457,7 @@ class zonda(Exchange, ImplicitAPI):
             'EUR': True,
             'PLN': True,
         }
-        return self.safe_value(fiatCurrencies, currency, False)
+        return self.safe_bool(fiatCurrencies, currency, False)
 
     def parse_deposit_address(self, depositAddress, currency: Currency = None):
         #
@@ -1588,7 +1588,7 @@ class zonda(Exchange, ImplicitAPI):
         #
         transfer = self.parse_transfer(response, currency)
         transferOptions = self.safe_value(self.options, 'transfer', {})
-        fillResponseFromRequest = self.safe_value(transferOptions, 'fillResponseFromRequest', True)
+        fillResponseFromRequest = self.safe_bool(transferOptions, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
             transfer['amount'] = amount
         return transfer

ccxt/base/errors.py

@@ -10,9 +10,11 @@ error_hierarchy = {
             'ArgumentsRequired': {},
             'BadRequest': {
                 'BadSymbol': {},
-                'MarginModeAlreadySet': {},
-                'NoChange': {},
-                'OperationRejected': {},
+            },
+            'OperationRejected': {
+                'NoChange': {
+                    'MarginModeAlreadySet': {},
+                },
             },
             'BadResponse': {
                 'NullResponse': {},
@@ -35,9 +37,8 @@ error_hierarchy = {
         },
         'OperationFailed': {
             'NetworkError': {
-                'DDoSProtection': {
-                    'RateLimitExceeded': {},
-                },
+                'DDoSProtection': {},
+                'RateLimitExceeded': {},
                 'ExchangeNotAvailable': {
                     'OnMaintenance': {},
                 },
@@ -86,15 +87,15 @@ class BadSymbol(BadRequest):
     pass
 
 
-class MarginModeAlreadySet(BadRequest):
+class OperationRejected(ExchangeError):
     pass
 
 
-class NoChange(BadRequest):
+class NoChange(OperationRejected):
     pass
 
 
-class OperationRejected(BadRequest):
+class MarginModeAlreadySet(NoChange):
     pass
 
 
@@ -170,7 +171,7 @@ class DDoSProtection(NetworkError):
     pass
 
 
-class RateLimitExceeded(DDoSProtection):
+class RateLimitExceeded(NetworkError):
     pass
 
 
@@ -205,9 +206,9 @@ __all__ = [
     'ArgumentsRequired',
     'BadRequest',
     'BadSymbol',
-    'MarginModeAlreadySet',
-    'NoChange',
     'OperationRejected',
+    'NoChange',
+    'MarginModeAlreadySet',
     'BadResponse',
     'NullResponse',
     'InsufficientFunds',

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.2.29'
+__version__ = '4.2.31'
 
 # -----------------------------------------------------------------------------
 
@@ -851,6 +851,8 @@ class Exchange(object):
 
     @staticmethod
     def safe_integer_product_n(dictionary, key_list, factor, default_value=None):
+        if dictionary is None:
+            return default_value
         value = Exchange.get_object_value_from_key_list(dictionary, key_list)
         if value is None:
             return default_value
@@ -869,6 +871,8 @@ class Exchange(object):
 
     @staticmethod
     def safe_value_n(dictionary, key_list, default_value=None):
+        if dictionary is None:
+            return default_value
         value = Exchange.get_object_value_from_key_list(dictionary, key_list)
         return value if value is not None else default_value
 
@@ -1965,7 +1969,7 @@ class Exchange(object):
                 result.append(messageHash)
         return result
 
-    def filter_by_limit(self, array: List[object], limit: Int = None, key: IndexType = 'timestamp'):
+    def filter_by_limit(self, array: List[object], limit: Int = None, key: IndexType = 'timestamp', fromStart: bool = False):
         if self.valueIsDefined(limit):
             arrayLength = len(array)
             if arrayLength > 0:
@@ -1975,7 +1979,10 @@ class Exchange(object):
                     last = array[arrayLength - 1][key]
                     if first is not None and last is not None:
                         ascending = first <= last  # True if array is sorted in ascending order based on 'timestamp'
-                array = self.arraySlice(array, -limit) if ascending else self.arraySlice(array, 0, limit)
+                if fromStart:
+                    array = self.arraySlice(array, 0, limit) if ascending else self.arraySlice(array, -limit)
+                else:
+                    array = self.arraySlice(array, -limit) if ascending else self.arraySlice(array, 0, limit)
         return array
 
     def filter_by_since_limit(self, array: List[object], since: Int = None, limit: Int = None, key: IndexType = 'timestamp', tail=False):
@@ -1991,7 +1998,10 @@ class Exchange(object):
                     result.append(entry)
         if tail and limit is not None:
             return self.arraySlice(result, -limit)
-        return self.filter_by_limit(result, limit, key)
+        # if the user provided a 'since' argument
+        # we want to limit the result starting from the 'since'
+        shouldFilterFromStart = not tail and sinceIsDefined
+        return self.filter_by_limit(result, limit, key, shouldFilterFromStart)
 
     def filter_by_value_since_limit(self, array: List[object], field: IndexType, value=None, since: Int = None, limit: Int = None, key='timestamp', tail=False):
         valueIsDefined = self.valueIsDefined(value)
@@ -2012,7 +2022,7 @@ class Exchange(object):
                     result.append(entry)
         if tail and limit is not None:
             return self.arraySlice(result, -limit)
-        return self.filter_by_limit(result, limit, key)
+        return self.filter_by_limit(result, limit, key, sinceIsDefined)
 
     def set_sandbox_mode(self, enabled):
         if enabled:
@@ -2234,7 +2244,7 @@ class Exchange(object):
         if fee is not None:
             fee['cost'] = self.safe_number(fee, 'cost')
         timestamp = self.safe_integer(entry, 'timestamp')
-        info = self.safe_value(entry, 'info', {})
+        info = self.safe_dict(entry, 'info', {})
         return {
             'id': self.safe_string(entry, 'id'),
             'timestamp': timestamp,
@@ -2392,7 +2402,7 @@ class Exchange(object):
             for i in range(0, len(values)):
                 market = values[i]
                 defaultCurrencyPrecision = 8 if (self.precisionMode == DECIMAL_PLACES) else self.parse_number('1e-8')
-                marketPrecision = self.safe_value(market, 'precision', {})
+                marketPrecision = self.safe_dict(market, 'precision', {})
                 if 'base' in market:
                     currency = self.safe_currency_structure({
                         'id': self.safe_string_2(market, 'baseId', 'base'),
@@ -2419,7 +2429,7 @@ class Exchange(object):
             resultingCurrencies = []
             for i in range(0, len(codes)):
                 code = codes[i]
-                groupedCurrenciesCode = self.safe_value(groupedCurrencies, code, [])
+                groupedCurrenciesCode = self.safe_list(groupedCurrencies, code, [])
                 highestPrecisionCurrency = self.safe_value(groupedCurrenciesCode, 0)
                 for j in range(1, len(groupedCurrenciesCode)):
                     currentCurrency = groupedCurrenciesCode[j]
@@ -2491,7 +2501,7 @@ class Exchange(object):
         parseSymbol = symbol is None
         parseSide = side is None
         shouldParseFees = parseFee or parseFees
-        fees = self.safe_value(order, 'fees', [])
+        fees = self.safe_list(order, 'fees', [])
         trades = []
         if parseFilled or parseCost or shouldParseFees:
             rawTrades = self.safe_value(order, 'trades', trades)
@@ -2586,7 +2596,7 @@ class Exchange(object):
             elif status == 'closed':
                 remaining = '0'
         # ensure that the average field is calculated correctly
-        inverse = self.safe_value(market, 'inverse', False)
+        inverse = self.safe_bool(market, 'inverse', False)
         contractSize = self.number_to_string(self.safe_value(market, 'contractSize', 1))
         # inverse
         # price = filled * contract size / cost
@@ -2630,11 +2640,11 @@ class Exchange(object):
             entry['amount'] = self.safe_number(entry, 'amount')
             entry['price'] = self.safe_number(entry, 'price')
             entry['cost'] = self.safe_number(entry, 'cost')
-            tradeFee = self.safe_value(entry, 'fee', {})
+            tradeFee = self.safe_dict(entry, 'fee', {})
             tradeFee['cost'] = self.safe_number(tradeFee, 'cost')
             if 'rate' in tradeFee:
                 tradeFee['rate'] = self.safe_number(tradeFee, 'rate')
-            entryFees = self.safe_value(entry, 'fees', [])
+            entryFees = self.safe_list(entry, 'fees', [])
             for j in range(0, len(entryFees)):
                 entryFees[j]['cost'] = self.safe_number(entryFees[j], 'cost')
             entry['fees'] = entryFees
@@ -2788,7 +2798,7 @@ class Exchange(object):
             contractSize = self.safe_string(market, 'contractSize')
             multiplyPrice = price
             if contractSize is not None:
-                inverse = self.safe_value(market, 'inverse', False)
+                inverse = self.safe_bool(market, 'inverse', False)
                 if inverse:
                     multiplyPrice = Precise.string_div('1', price)
                 multiplyPrice = Precise.string_mul(multiplyPrice, contractSize)
@@ -2998,12 +3008,12 @@ class Exchange(object):
 
     def convert_trading_view_to_ohlcv(self, ohlcvs, timestamp='t', open='o', high='h', low='l', close='c', volume='v', ms=False):
         result = []
-        timestamps = self.safe_value(ohlcvs, timestamp, [])
-        opens = self.safe_value(ohlcvs, open, [])
-        highs = self.safe_value(ohlcvs, high, [])
-        lows = self.safe_value(ohlcvs, low, [])
-        closes = self.safe_value(ohlcvs, close, [])
-        volumes = self.safe_value(ohlcvs, volume, [])
+        timestamps = self.safe_list(ohlcvs, timestamp, [])
+        opens = self.safe_list(ohlcvs, open, [])
+        highs = self.safe_list(ohlcvs, high, [])
+        lows = self.safe_list(ohlcvs, low, [])
+        closes = self.safe_list(ohlcvs, close, [])
+        volumes = self.safe_list(ohlcvs, volume, [])
         for i in range(0, len(timestamps)):
             result.append([
                 self.safe_integer(timestamps, i) if ms else self.safe_timestamp(timestamps, i),
@@ -3036,10 +3046,10 @@ class Exchange(object):
     def fetch_web_endpoint(self, method, endpointMethod, returnAsJson, startRegex=None, endRegex=None):
         errorMessage = ''
         options = self.safe_value(self.options, method, {})
-        muteOnFailure = self.safe_value(options, 'webApiMuteFailure', True)
+        muteOnFailure = self.safe_bool(options, 'webApiMuteFailure', True)
         try:
             # if it was not explicitly disabled, then don't fetch
-            if self.safe_value(options, 'webApiEnable', True) is not True:
+            if self.safe_bool(options, 'webApiEnable', True) is not True:
                 return None
             maxRetries = self.safe_value(options, 'webApiRetries', 10)
             response = None
@@ -3204,7 +3214,7 @@ class Exchange(object):
         if currencyCode is not None:
             defaultNetworkCodeReplacements = self.safe_value(self.options, 'defaultNetworkCodeReplacements', {})
             if currencyCode in defaultNetworkCodeReplacements:
-                replacementObject = self.safe_value(defaultNetworkCodeReplacements, currencyCode, {})
+                replacementObject = self.safe_dict(defaultNetworkCodeReplacements, currencyCode, {})
                 networkCode = self.safe_string(replacementObject, networkCode, networkCode)
         return networkCode
 
@@ -3291,7 +3301,7 @@ class Exchange(object):
             id = self.safe_string(item, marketIdKey)
             market = self.safe_market(id, None, None, 'swap')
             symbol = market['symbol']
-            contract = self.safe_value(market, 'contract', False)
+            contract = self.safe_bool(market, 'contract', False)
             if contract and ((symbols is None) or self.in_array(symbol, symbols)):
                 tiers[symbol] = self.parse_market_leverage_tiers(item, market)
         return tiers
@@ -4297,8 +4307,8 @@ class Exchange(object):
         currency = self.currencies[code]
         precision = self.safe_value(currency, 'precision')
         if networkCode is not None:
-            networks = self.safe_value(currency, 'networks', {})
-            networkItem = self.safe_value(networks, networkCode, {})
+            networks = self.safe_dict(currency, 'networks', {})
+            networkItem = self.safe_dict(networks, networkCode, {})
             precision = self.safe_value(networkItem, 'precision', precision)
         if precision is None:
             return self.forceString(fee)
@@ -4561,7 +4571,7 @@ class Exchange(object):
         :returns Array:
         """
         timeInForce = self.safe_string_upper(params, 'timeInForce')
-        postOnly = self.safe_value(params, 'postOnly', False)
+        postOnly = self.safe_bool(params, 'postOnly', False)
         ioc = timeInForce == 'IOC'
         fok = timeInForce == 'FOK'
         po = timeInForce == 'PO'

ccxt/bigone.py

@@ -1406,7 +1406,7 @@ class bigone(Exchange, ImplicitAPI):
         requestSide = 'BID' if isBuy else 'ASK'
         uppercaseType = type.upper()
         isLimit = uppercaseType == 'LIMIT'
-        exchangeSpecificParam = self.safe_value(params, 'post_only', False)
+        exchangeSpecificParam = self.safe_bool(params, 'post_only', False)
         postOnly = None
         postOnly, params = self.handle_post_only((uppercaseType == 'MARKET'), exchangeSpecificParam, params)
         triggerPrice = self.safe_string_n(params, ['triggerPrice', 'stopPrice', 'stop_price'])
@@ -1987,7 +1987,7 @@ class bigone(Exchange, ImplicitAPI):
         #
         transfer = self.parse_transfer(response, currency)
         transferOptions = self.safe_value(self.options, 'transfer', {})
-        fillResponseFromRequest = self.safe_value(transferOptions, 'fillResponseFromRequest', True)
+        fillResponseFromRequest = self.safe_bool(transferOptions, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
             transfer['fromAccount'] = fromAccount
             transfer['toAccount'] = toAccount