ccxt 4.4.92__py2.py3-none-any.whl → 4.4.93__py2.py3-none-any.whl

ccxt/coinbaseexchange.py

@@ -39,31 +39,73 @@ class coinbaseexchange(Exchange, ImplicitAPI):
                 'swap': False,
                 'future': False,
                 'option': False,
+                'addMargin': False,
+                'borrowCrossMargin': False,
+                'borrowIsolatedMargin': False,
+                'borrowMargin': False,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'closeAllPositions': False,
+                'closePosition': False,
                 'createDepositAddress': True,
                 'createOrder': True,
+                'createOrderWithTakeProfitAndStopLoss': False,
+                'createOrderWithTakeProfitAndStopLossWs': False,
+                'createPostOnlyOrder': False,
                 'createReduceOnlyOrder': False,
                 'createStopLimitOrder': True,
                 'createStopMarketOrder': True,
                 'createStopOrder': True,
                 'fetchAccounts': True,
                 'fetchBalance': True,
+                'fetchBorrowInterest': False,
+                'fetchBorrowRate': False,
+                'fetchBorrowRateHistories': False,
+                'fetchBorrowRateHistory': False,
+                'fetchBorrowRates': False,
+                'fetchBorrowRatesPerSymbol': False,
                 'fetchClosedOrders': True,
+                'fetchCrossBorrowRate': False,
+                'fetchCrossBorrowRates': False,
                 'fetchCurrencies': True,
                 'fetchDepositAddress': False,  # the exchange does not have self method, only createDepositAddress, see https://github.com/ccxt/ccxt/pull/7405
                 'fetchDeposits': True,
                 'fetchDepositsWithdrawals': True,
                 'fetchFundingHistory': False,
+                'fetchFundingInterval': False,
+                'fetchFundingIntervals': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': False,
+                'fetchIndexOHLCV': False,
+                'fetchIsolatedBorrowRate': False,
+                'fetchIsolatedBorrowRates': False,
+                'fetchIsolatedPositions': False,
                 'fetchLedger': True,
+                'fetchLeverage': False,
+                'fetchLeverages': False,
+                'fetchLeverageTiers': False,
+                'fetchLiquidations': False,
+                'fetchLongShortRatio': False,
+                'fetchLongShortRatioHistory': False,
+                'fetchMarginAdjustmentHistory': False,
                 'fetchMarginMode': False,
+                'fetchMarginModes': False,
+                'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
+                'fetchMarkOHLCV': False,
+                'fetchMarkPrices': False,
+                'fetchMyLiquidations': False,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
+                'fetchOpenInterest': False,
+                'fetchOpenInterestHistory': False,
+                'fetchOpenInterests': False,
                 'fetchOpenOrders': True,
+                'fetchOption': False,
+                'fetchOptionChain': False,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrders': True,
@@ -75,6 +117,8 @@ class coinbaseexchange(Exchange, ImplicitAPI):
                 'fetchPositionsForSymbol': False,
                 'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
+                'fetchPremiumIndexOHLCV': False,
+                'fetchSettlementHistory': False,
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTime': True,
@@ -82,7 +126,16 @@ class coinbaseexchange(Exchange, ImplicitAPI):
                 'fetchTradingFee': False,
                 'fetchTradingFees': True,
                 'fetchTransactions': 'emulated',
+                'fetchVolatilityHistory': False,
                 'fetchWithdrawals': True,
+                'reduceMargin': False,
+                'repayCrossMargin': False,
+                'repayIsolatedMargin': False,
+                'repayMargin': False,
+                'setLeverage': False,
+                'setMargin': False,
+                'setMarginMode': False,
+                'setPositionMode': False,
                 'withdraw': True,
             },
             'timeframes': {

ccxt/coincheck.py

@@ -10,6 +10,7 @@ from ccxt.base.types import Any, Balances, Currency, Int, Market, Num, Order, Or
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadSymbol
 from ccxt.base.decimal_to_precision import TICK_SIZE
 
@@ -30,30 +31,59 @@ class coincheck(Exchange, ImplicitAPI):
                 'future': False,
                 'option': False,
                 'addMargin': False,
+                'borrowCrossMargin': False,
+                'borrowIsolatedMargin': False,
+                'borrowMargin': False,
                 'cancelOrder': True,
                 'closeAllPositions': False,
                 'closePosition': False,
                 'createOrder': True,
+                'createOrderWithTakeProfitAndStopLoss': False,
+                'createOrderWithTakeProfitAndStopLossWs': False,
+                'createPostOnlyOrder': False,
                 'createReduceOnlyOrder': False,
                 'fetchBalance': True,
+                'fetchBorrowInterest': False,
+                'fetchBorrowRate': False,
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
+                'fetchBorrowRates': False,
+                'fetchBorrowRatesPerSymbol': False,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
                 'fetchDeposits': True,
                 'fetchFundingHistory': False,
+                'fetchFundingInterval': False,
+                'fetchFundingIntervals': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': False,
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
+                'fetchIsolatedPositions': False,
                 'fetchLeverage': False,
+                'fetchLeverages': False,
+                'fetchLeverageTiers': False,
+                'fetchLiquidations': False,
+                'fetchLongShortRatio': False,
+                'fetchLongShortRatioHistory': False,
+                'fetchMarginAdjustmentHistory': False,
                 'fetchMarginMode': False,
+                'fetchMarginModes': False,
+                'fetchMarketLeverageTiers': False,
                 'fetchMarkOHLCV': False,
+                'fetchMarkPrices': False,
+                'fetchMyLiquidations': False,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
+                'fetchOpenInterest': False,
                 'fetchOpenInterestHistory': False,
+                'fetchOpenInterests': False,
                 'fetchOpenOrders': True,
+                'fetchOption': False,
+                'fetchOptionChain': False,
                 'fetchOrderBook': True,
                 'fetchPosition': False,
                 'fetchPositionHistory': False,
@@ -63,13 +93,19 @@ class coincheck(Exchange, ImplicitAPI):
                 'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
+                'fetchSettlementHistory': False,
                 'fetchTicker': True,
                 'fetchTrades': True,
                 'fetchTradingFee': False,
                 'fetchTradingFees': True,
+                'fetchVolatilityHistory': False,
                 'fetchWithdrawals': True,
                 'reduceMargin': False,
+                'repayCrossMargin': False,
+                'repayIsolatedMargin': False,
+                'repayMargin': False,
                 'setLeverage': False,
+                'setMargin': False,
                 'setMarginMode': False,
                 'setPositionMode': False,
                 'ws': True,
@@ -637,10 +673,15 @@ class coincheck(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         if type == 'market':
-            order_type = type + '_' + side
-            request['order_type'] = order_type
-            prefix = (order_type + '_') if (side == 'buy') else ''
-            request[prefix + 'amount'] = amount
+            request['order_type'] = type + '_' + side
+            if side == 'sell':
+                request['amount'] = amount
+            else:
+                cost = self.safe_number(params, 'cost')
+                params = self.omit(params, 'cost')
+                if cost is not None:
+                    raise ArgumentsRequired(self.id + ' createOrder() : you should use "cost" parameter instead of "amount" argument to create market buy orders')
+                request['market_buy_amount'] = cost
         else:
             request['order_type'] = side
             request['rate'] = price

ccxt/coinex.py

@@ -18,6 +18,7 @@ from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
+from ccxt.base.errors import OperationFailed
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
 from ccxt.base.errors import RequestTimeout
@@ -670,6 +671,7 @@ class coinex(Exchange, ImplicitAPI):
                 'broad': {
                     'ip not allow visit': PermissionDenied,
                     'service too busy': ExchangeNotAvailable,
+                    'Service is not available during funding fee settlement': OperationFailed,
                 },
             },
         })
@@ -794,7 +796,7 @@ class coinex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},
+                'networks': networks,
                 'type': 'crypto',
                 'info': coin,
             })
@@ -826,17 +828,19 @@ class coinex(Exchange, ImplicitAPI):
         #         "code": 0,
         #         "data": [
         #             {
-        #                 "base_ccy": "SORA",
+        #                 "market": "BTCUSDT",
+        #                 "taker_fee_rate": "0.002",
+        #                 "maker_fee_rate": "0.002",
+        #                 "min_amount": "0.0005",
+        #                 "base_ccy": "BTC",
+        #                 "quote_ccy": "USDT",
         #                 "base_ccy_precision": 8,
+        #                 "quote_ccy_precision": 2,
         #                 "is_amm_available": True,
-        #                 "is_margin_available": False,
-        #                 "maker_fee_rate": "0.003",
-        #                 "market": "SORAUSDT",
-        #                 "min_amount": "500",
-        #                 "quote_ccy": "USDT",
-        #                 "quote_ccy_precision": 6,
-        #                 "taker_fee_rate": "0.003"
-        #             },
+        #                 "is_margin_available": True,
+        #                 "is_pre_trading_available": True,
+        #                 "is_api_trading_available": True
+        #             }
         #         ],
         #         "message": "OK"
         #     }
@@ -862,11 +866,11 @@ class coinex(Exchange, ImplicitAPI):
                 'settleId': None,
                 'type': 'spot',
                 'spot': True,
-                'margin': None,
+                'margin': self.safe_bool(market, 'is_margin_available'),
                 'swap': False,
                 'future': False,
                 'option': False,
-                'active': None,
+                'active': self.safe_bool(market, 'is_api_trading_available'),
                 'contract': False,
                 'linear': None,
                 'inverse': None,

ccxt/cryptomus.py

@@ -367,66 +367,44 @@ class cryptomus(Exchange, ImplicitAPI):
         #     }
         #
         coins = self.safe_list(response, 'result')
+        groupedById = self.group_by(coins, 'currency_code')
+        keys = list(groupedById.keys())
         result: dict = {}
-        for i in range(0, len(coins)):
-            networkEntry = coins[i]
-            currencyId = self.safe_string(networkEntry, 'currency_code')
-            code = self.safe_currency_code(currencyId)
-            if not (code in result):
-                result[code] = {
-                    'id': currencyId,
-                    'code': code,
-                    'precision': None,
-                    'type': None,
-                    'name': None,
-                    'active': None,
-                    'deposit': None,
-                    'withdraw': None,
-                    'fee': None,
+        for i in range(0, len(keys)):
+            id = keys[i]
+            code = self.safe_currency_code(id)
+            networks = {}
+            networkEntries = groupedById[id]
+            for j in range(0, len(networkEntries)):
+                networkEntry = networkEntries[j]
+                networkId = self.safe_string(networkEntry, 'network_code')
+                networkCode = self.network_id_to_code(networkId)
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
                     'limits': {
                         'withdraw': {
-                            'min': None,
-                            'max': None,
+                            'min': self.safe_number(networkEntry, 'min_withdraw'),
+                            'max': self.safe_number(networkEntry, 'max_withdraw'),
                         },
                         'deposit': {
-                            'min': None,
-                            'max': None,
+                            'min': self.safe_number(networkEntry, 'min_deposit'),
+                            'max': self.safe_number(networkEntry, 'max_deposit'),
                         },
                     },
-                    'networks': {},
-                    'info': {},
+                    'active': None,
+                    'deposit': self.safe_bool(networkEntry, 'can_withdraw'),
+                    'withdraw': self.safe_bool(networkEntry, 'can_deposit'),
+                    'fee': None,
+                    'precision': None,
+                    'info': networkEntry,
                 }
-            networkId = self.safe_string(networkEntry, 'network_code')
-            networkCode = self.network_id_to_code(networkId)
-            result[code]['networks'][networkCode] = {
-                'id': networkId,
-                'network': networkCode,
-                'limits': {
-                    'withdraw': {
-                        'min': self.safe_number(networkEntry, 'min_withdraw'),
-                        'max': self.safe_number(networkEntry, 'max_withdraw'),
-                    },
-                    'deposit': {
-                        'min': self.safe_number(networkEntry, 'min_deposit'),
-                        'max': self.safe_number(networkEntry, 'max_deposit'),
-                    },
-                },
-                'active': None,
-                'deposit': self.safe_bool(networkEntry, 'can_withdraw'),
-                'withdraw': self.safe_bool(networkEntry, 'can_deposit'),
-                'fee': None,
-                'precision': None,
-                'info': networkEntry,
-            }
-            # add entry in info
-            info = self.safe_list(result[code], 'info', [])
-            info.append(networkEntry)
-            result[code]['info'] = info
-        # only after all entries are formed in currencies, restructure each entry
-        allKeys = list(result.keys())
-        for i in range(0, len(allKeys)):
-            code = allKeys[i]
-            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
+            result[code] = self.safe_currency_structure({
+                'id': id,
+                'code': code,
+                'networks': networks,
+                'info': networkEntries,
+            })
         return result
 
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:

ccxt/deribit.py

@@ -2596,21 +2596,21 @@ class deribit(Exchange, ImplicitAPI):
         unrealizedPnl = self.safe_string(position, 'floating_profit_loss')
         initialMarginString = self.safe_string(position, 'initial_margin')
         notionalString = self.safe_string(position, 'size_currency')
+        notionalStringAbs = Precise.string_abs(notionalString)
         maintenanceMarginString = self.safe_string(position, 'maintenance_margin')
-        currentTime = self.milliseconds()
         return self.safe_position({
             'info': position,
             'id': None,
             'symbol': self.safe_string(market, 'symbol'),
-            'timestamp': currentTime,
-            'datetime': self.iso8601(currentTime),
+            'timestamp': None,
+            'datetime': None,
             'lastUpdateTimestamp': None,
             'initialMargin': self.parse_number(initialMarginString),
-            'initialMarginPercentage': self.parse_number(Precise.string_mul(Precise.string_div(initialMarginString, notionalString), '100')),
+            'initialMarginPercentage': self.parse_number(Precise.string_mul(Precise.string_div(initialMarginString, notionalStringAbs), '100')),
             'maintenanceMargin': self.parse_number(maintenanceMarginString),
-            'maintenanceMarginPercentage': self.parse_number(Precise.string_mul(Precise.string_div(maintenanceMarginString, notionalString), '100')),
+            'maintenanceMarginPercentage': self.parse_number(Precise.string_mul(Precise.string_div(maintenanceMarginString, notionalStringAbs), '100')),
             'entryPrice': self.safe_number(position, 'average_price'),
-            'notional': self.parse_number(notionalString),
+            'notional': self.parse_number(notionalStringAbs),
             'leverage': self.safe_integer(position, 'leverage'),
             'unrealizedPnl': self.parse_number(unrealizedPnl),
             'contracts': None,

ccxt/exmo.py

@@ -709,73 +709,85 @@ class exmo(Exchange, ImplicitAPI):
         for i in range(0, len(currencyList)):
             currency = currencyList[i]
             currencyId = self.safe_string(currency, 'name')
-            name = self.safe_string(currency, 'description')
-            providers = self.safe_value(cryptoList, currencyId)
-            active = False
+            code = self.safe_currency_code(currencyId)
             type = 'crypto'
-            limits: dict = {
-                'deposit': {
-                    'min': None,
-                    'max': None,
-                },
-                'withdraw': {
-                    'min': None,
-                    'max': None,
-                },
-            }
-            fee = None
-            depositEnabled = None
-            withdrawEnabled = None
+            networks = {}
+            providers = self.safe_list(cryptoList, currencyId)
             if providers is None:
-                active = True
                 type = 'fiat'
             else:
                 for j in range(0, len(providers)):
                     provider = providers[j]
+                    name = self.safe_string(provider, 'name')
+                    # get network-id by removing extra things
+                    networkId = name.replace(currencyId + ' ', '')
+                    networkId = networkId.replace('(', '')
+                    replaceChar = ')'  # transpiler trick
+                    networkId = networkId.replace(replaceChar, '')
+                    networkCode = self.network_id_to_code(networkId)
+                    if not (networkCode in networks):
+                        networks[networkCode] = {
+                            'id': networkId,
+                            'network': networkCode,
+                            'active': None,
+                            'deposit': None,
+                            'withdraw': None,
+                            'fee': None,
+                            'limits': {
+                                'withdraw': {
+                                    'min': None,
+                                    'max': None,
+                                },
+                                'deposit': {
+                                    'min': None,
+                                    'max': None,
+                                },
+                            },
+                            'info': [],  # set, because of multiple network sub-entries
+                        }
                     typeInner = self.safe_string(provider, 'type')
                     minValue = self.safe_string(provider, 'min')
                     maxValue = self.safe_string(provider, 'max')
-                    if Precise.string_eq(maxValue, '0.0'):
-                        maxValue = None
-                    activeProvider = self.safe_value(provider, 'enabled')
+                    activeProvider = self.safe_bool(provider, 'enabled')
+                    networkEntry = networks[networkCode]
                     if typeInner == 'deposit':
-                        if activeProvider and not depositEnabled:
-                            depositEnabled = True
-                        elif not activeProvider:
-                            depositEnabled = False
+                        networkEntry['deposit'] = activeProvider
+                        networkEntry['limits']['deposit']['min'] = minValue
+                        networkEntry['limits']['deposit']['max'] = maxValue
                     elif typeInner == 'withdraw':
-                        if activeProvider and not withdrawEnabled:
-                            withdrawEnabled = True
-                        elif not activeProvider:
-                            withdrawEnabled = False
-                    if activeProvider:
-                        active = True
-                        limitMin = self.number_to_string(limits[typeInner]['min'])
-                        if (limits[typeInner]['min'] is None) or (Precise.string_lt(minValue, limitMin)):
-                            limits[typeInner]['min'] = minValue
-                            limits[typeInner]['max'] = maxValue
-                            if typeInner == 'withdraw':
-                                commissionDesc = self.safe_string(provider, 'commission_desc')
-                                fee = self.parse_fixed_float_value(commissionDesc)
-            code = self.safe_currency_code(currencyId)
-            info = {
-                'currency': currency,
-                'providers': providers,
-            }
-            result[code] = {
+                        networkEntry['withdraw'] = activeProvider
+                        networkEntry['limits']['withdraw']['min'] = minValue
+                        networkEntry['limits']['withdraw']['max'] = maxValue
+                    info = self.safe_list(networkEntry, 'info')
+                    info.append(provider)
+                    networkEntry['info'] = info
+                    networks[networkCode] = networkEntry
+            result[code] = self.safe_currency_structure({
                 'id': currencyId,
                 'code': code,
-                'name': name,
+                'name': self.safe_string(currency, 'description'),
                 'type': type,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'fee': fee,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
                 'precision': self.parse_number('1e-8'),
-                'limits': limits,
-                'info': info,
-                'networks': {},
-            }
+                'limits': {
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'info': {
+                    'currency': currency,
+                    'providers': providers,
+                },
+                'networks': networks,
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:

ccxt/hyperliquid.py

@@ -695,7 +695,8 @@ class hyperliquid(Exchange, ImplicitAPI):
         #     }
         #
         quoteId = 'USDC'
-        base = self.safe_string(market, 'name')
+        baseName = self.safe_string(market, 'name')
+        base = self.safe_currency_code(baseName)
         quote = self.safe_currency_code(quoteId)
         baseId = self.safe_string(market, 'baseId')
         settleId = 'USDC'

ccxt/kucoin.py

@@ -1396,35 +1396,31 @@ class kucoin(Exchange, ImplicitAPI):
         #    }
         #
         currenciesData = self.safe_list(response, 'data', [])
+        brokenCurrencies = self.safe_list(self.options, 'brokenCurrencies', ['00', 'OPEN_ERROR', 'HUF', 'BDT'])
+        otherFiats = self.safe_list(self.options, 'fiats', ['KWD', 'IRR', 'PKR'])
         result: dict = {}
         for i in range(0, len(currenciesData)):
             entry = currenciesData[i]
             id = self.safe_string(entry, 'currency')
-            name = self.safe_string(entry, 'fullName')
+            if self.in_array(id, brokenCurrencies):
+                continue  # skip buggy entries: https://t.me/KuCoin_API/217798
             code = self.safe_currency_code(id)
             networks: dict = {}
             chains = self.safe_list(entry, 'chains', [])
-            rawPrecision = self.safe_string(entry, 'precision')
-            precision = self.parse_number(self.parse_precision(rawPrecision))
             chainsLength = len(chains)
-            if not chainsLength:
-                # one buggy coin, which doesn't contain info https://t.me/KuCoin_API/173118
-                continue
             for j in range(0, chainsLength):
                 chain = chains[j]
                 chainId = self.safe_string(chain, 'chainId')
                 networkCode = self.network_id_to_code(chainId, code)
-                chainWithdrawEnabled = self.safe_bool(chain, 'isWithdrawEnabled', False)
-                chainDepositEnabled = self.safe_bool(chain, 'isDepositEnabled', False)
                 networks[networkCode] = {
                     'info': chain,
                     'id': chainId,
                     'name': self.safe_string(chain, 'chainName'),
                     'code': networkCode,
-                    'active': chainWithdrawEnabled and chainDepositEnabled,
+                    'active': None,
                     'fee': self.safe_number(chain, 'withdrawalMinFee'),
-                    'deposit': chainDepositEnabled,
-                    'withdraw': chainWithdrawEnabled,
+                    'deposit': self.safe_bool(chain, 'isDepositEnabled'),
+                    'withdraw': self.safe_bool(chain, 'isWithdrawEnabled'),
                     'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'withdrawPrecision'))),
                     'limits': {
                         'withdraw': {
@@ -1438,10 +1434,12 @@ class kucoin(Exchange, ImplicitAPI):
                     },
                 }
             # kucoin has determined 'fiat' currencies with below logic
-            isFiat = (rawPrecision == '2') and (chainsLength == 0)
+            rawPrecision = self.safe_string(entry, 'precision')
+            precision = self.parse_number(self.parse_precision(rawPrecision))
+            isFiat = self.in_array(id, otherFiats) or ((rawPrecision == '2') and (chainsLength == 0))
             result[code] = self.safe_currency_structure({
                 'id': id,
-                'name': name,
+                'name': self.safe_string(entry, 'fullName'),
                 'code': code,
                 'type': 'fiat' if isFiat else 'crypto',
                 'precision': precision,
@@ -2627,7 +2625,7 @@ class kucoin(Exchange, ImplicitAPI):
         """
         self.load_markets()
         request: dict = {}
-        trigger = self.safe_bool(params, 'stop', False)
+        trigger = self.safe_bool_2(params, 'trigger', 'stop', False)
         hf = None
         hf, params = self.handle_hf_and_params(params)
         params = self.omit(params, 'stop')