From 8d111d357afa0c44214c9990798dae2918733880 Mon Sep 17 00:00:00 2001 From: Matthias Date: Fri, 25 Mar 2022 06:46:29 +0100 Subject: [PATCH] Update SellCheckTuple to new naming --- freqtrade/freqtradebot.py | 26 ++++++++++----------- freqtrade/optimize/backtesting.py | 24 +++++++++---------- freqtrade/rpc/rpc.py | 4 ++-- freqtrade/strategy/interface.py | 38 +++++++++++++++---------------- tests/strategy/test_interface.py | 38 +++++++++++++++---------------- tests/test_freqtradebot.py | 28 +++++++++++------------ tests/test_integration.py | 16 ++++++------- 7 files changed, 87 insertions(+), 87 deletions(-) diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py index f2aca0d09..eae776546 100644 --- a/freqtrade/freqtradebot.py +++ b/freqtrade/freqtradebot.py @@ -27,7 +27,7 @@ from freqtrade.plugins.pairlistmanager import PairListManager from freqtrade.plugins.protectionmanager import ProtectionManager from freqtrade.resolvers import ExchangeResolver, StrategyResolver from freqtrade.rpc import RPCManager -from freqtrade.strategy.interface import IStrategy, SellCheckTuple +from freqtrade.strategy.interface import IStrategy, ExitCheckTuple from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper from freqtrade.wallets import Wallets @@ -976,8 +976,8 @@ class FreqtradeBot(LoggingMixin): trade.stoploss_order_id = None logger.error(f'Unable to place a stoploss order on exchange. {e}') logger.warning('Exiting the trade forcefully') - self.execute_trade_exit(trade, trade.stop_loss, exit_check=SellCheckTuple( - sell_type=SellType.EMERGENCY_SELL)) + self.execute_trade_exit(trade, trade.stop_loss, exit_check=ExitCheckTuple( + exit_type=SellType.EMERGENCY_SELL)) except ExchangeError: trade.stoploss_order_id = None @@ -1101,7 +1101,7 @@ class FreqtradeBot(LoggingMixin): """ Check and execute trade exit """ - should_exit: SellCheckTuple = self.strategy.should_exit( + should_exit: ExitCheckTuple = self.strategy.should_exit( trade, exit_rate, datetime.now(timezone.utc), @@ -1110,8 +1110,8 @@ class FreqtradeBot(LoggingMixin): force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0 ) - if should_exit.sell_flag: - logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.sell_type}' + if should_exit.exit_flag: + logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.exit_type}' f'Tag: {exit_tag if exit_tag is not None else "None"}') self.execute_trade_exit(trade, exit_rate, should_exit, exit_tag=exit_tag) return True @@ -1158,7 +1158,7 @@ class FreqtradeBot(LoggingMixin): try: self.execute_trade_exit( trade, order.get('price'), - exit_check=SellCheckTuple(sell_type=SellType.EMERGENCY_SELL)) + exit_check=ExitCheckTuple(exit_type=SellType.EMERGENCY_SELL)) except DependencyException as exception: logger.warning( f'Unable to emergency sell trade {trade.pair}: {exception}') @@ -1333,7 +1333,7 @@ class FreqtradeBot(LoggingMixin): self, trade: Trade, limit: float, - exit_check: SellCheckTuple, + exit_check: ExitCheckTuple, *, exit_tag: Optional[str] = None, ordertype: Optional[str] = None, @@ -1352,7 +1352,7 @@ class FreqtradeBot(LoggingMixin): open_date=trade.open_date, ) exit_type = 'exit' - if exit_check.sell_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS): + if exit_check.exit_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS): exit_type = 'stoploss' # if stoploss is on exchange and we are on dry_run mode, @@ -1376,7 +1376,7 @@ class FreqtradeBot(LoggingMixin): trade = self.cancel_stoploss_on_exchange(trade) order_type = ordertype or self.strategy.order_types[exit_type] - if exit_check.sell_type == SellType.EMERGENCY_SELL: + if exit_check.exit_type == SellType.EMERGENCY_SELL: # Emergency sells (default to market!) order_type = self.strategy.order_types.get("emergencyexit", "market") @@ -1385,8 +1385,8 @@ class FreqtradeBot(LoggingMixin): if not strategy_safe_wrapper(self.strategy.confirm_trade_exit, default_retval=True)( pair=trade.pair, trade=trade, order_type=order_type, amount=amount, rate=limit, - time_in_force=time_in_force, exit_reason=exit_check.sell_reason, - sell_reason=exit_check.sell_reason, # sellreason -> compatibility + time_in_force=time_in_force, exit_reason=exit_check.exit_reason, + sell_reason=exit_check.exit_reason, # sellreason -> compatibility current_time=datetime.now(timezone.utc)): logger.info(f"User requested abortion of exiting {trade.pair}") return False @@ -1415,7 +1415,7 @@ class FreqtradeBot(LoggingMixin): trade.open_order_id = order['id'] trade.sell_order_status = '' trade.close_rate_requested = limit - trade.sell_reason = exit_tag or exit_check.sell_reason + trade.sell_reason = exit_tag or exit_check.exit_reason # Lock pair for one candle to prevent immediate re-trading self.strategy.lock_pair(trade.pair, datetime.now(timezone.utc), diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py index b4726f753..d4c0c4e48 100644 --- a/freqtrade/optimize/backtesting.py +++ b/freqtrade/optimize/backtesting.py @@ -31,7 +31,7 @@ from freqtrade.persistence import LocalTrade, Order, PairLocks, Trade from freqtrade.plugins.pairlistmanager import PairListManager from freqtrade.plugins.protectionmanager import ProtectionManager from freqtrade.resolvers import ExchangeResolver, StrategyResolver -from freqtrade.strategy.interface import IStrategy, SellCheckTuple +from freqtrade.strategy.interface import IStrategy, ExitCheckTuple from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper from freqtrade.wallets import Wallets @@ -352,20 +352,20 @@ class Backtesting: data[pair] = df_analyzed[headers].values.tolist() return data - def _get_close_rate(self, sell_row: Tuple, trade: LocalTrade, sell: SellCheckTuple, + def _get_close_rate(self, sell_row: Tuple, trade: LocalTrade, sell: ExitCheckTuple, trade_dur: int) -> float: """ Get close rate for backtesting result """ # Special handling if high or low hit STOP_LOSS or ROI - if sell.sell_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS): + if sell.exit_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS): return self._get_close_rate_for_stoploss(sell_row, trade, sell, trade_dur) - elif sell.sell_type == (SellType.ROI): + elif sell.exit_type == (SellType.ROI): return self._get_close_rate_for_roi(sell_row, trade, sell, trade_dur) else: return sell_row[OPEN_IDX] - def _get_close_rate_for_stoploss(self, sell_row: Tuple, trade: LocalTrade, sell: SellCheckTuple, + def _get_close_rate_for_stoploss(self, sell_row: Tuple, trade: LocalTrade, sell: ExitCheckTuple, trade_dur: int) -> float: # our stoploss was already lower than candle high, # possibly due to a cancelled trade exit. @@ -383,7 +383,7 @@ class Backtesting: # Special case: trailing triggers within same candle as trade opened. Assume most # pessimistic price movement, which is moving just enough to arm stoploss and # immediately going down to stop price. - if sell.sell_type == SellType.TRAILING_STOP_LOSS and trade_dur == 0: + if sell.exit_type == SellType.TRAILING_STOP_LOSS and trade_dur == 0: if ( not self.strategy.use_custom_stoploss and self.strategy.trailing_stop and self.strategy.trailing_only_offset_is_reached @@ -413,7 +413,7 @@ class Backtesting: # Set close_rate to stoploss return trade.stop_loss - def _get_close_rate_for_roi(self, sell_row: Tuple, trade: LocalTrade, sell: SellCheckTuple, + def _get_close_rate_for_roi(self, sell_row: Tuple, trade: LocalTrade, sell: ExitCheckTuple, trade_dur: int) -> float: is_short = trade.is_short or False leverage = trade.leverage or 1.0 @@ -521,7 +521,7 @@ class Backtesting: low=sell_row[LOW_IDX], high=sell_row[HIGH_IDX] ) - if sell.sell_flag: + if sell.exit_flag: trade.close_date = sell_candle_time trade_dur = int((trade.close_date_utc - trade.open_date_utc).total_seconds() // 60) @@ -532,7 +532,7 @@ class Backtesting: # call the custom exit price,with default value as previous closerate current_profit = trade.calc_profit_ratio(closerate) order_type = self.strategy.order_types['exit'] - if sell.sell_type in (SellType.SELL_SIGNAL, SellType.CUSTOM_SELL): + if sell.exit_type in (SellType.SELL_SIGNAL, SellType.CUSTOM_SELL): # Custom exit pricing only for sell-signals if order_type == 'limit': closerate = strategy_safe_wrapper(self.strategy.custom_exit_price, @@ -553,12 +553,12 @@ class Backtesting: pair=trade.pair, trade=trade, order_type='limit', amount=trade.amount, rate=closerate, time_in_force=time_in_force, - sell_reason=sell.sell_reason, # deprecated - exit_reason=sell.sell_reason, + sell_reason=sell.exit_reason, # deprecated + exit_reason=sell.exit_reason, current_time=sell_candle_time): return None - trade.sell_reason = sell.sell_reason + trade.sell_reason = sell.exit_reason # Checks and adds an exit tag, after checking that the length of the # sell_row has the length for an exit tag column diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py index 2c61c39ad..ed279e303 100644 --- a/freqtrade/rpc/rpc.py +++ b/freqtrade/rpc/rpc.py @@ -27,7 +27,7 @@ from freqtrade.persistence import PairLocks, Trade from freqtrade.persistence.models import PairLock from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist from freqtrade.rpc.fiat_convert import CryptoToFiatConverter -from freqtrade.strategy.interface import SellCheckTuple +from freqtrade.strategy.interface import ExitCheckTuple from freqtrade.wallets import PositionWallet, Wallet @@ -707,7 +707,7 @@ class RPC: # Get current rate and execute sell current_rate = self._freqtrade.exchange.get_rate( trade.pair, refresh=False, side=trade.exit_side) - exit_check = SellCheckTuple(sell_type=SellType.FORCE_SELL) + exit_check = ExitCheckTuple(exit_type=SellType.FORCE_SELL) order_type = ordertype or self._freqtrade.strategy.order_types.get( "forceexit", self._freqtrade.strategy.order_types["exit"]) diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py index 7b07d82c1..fc12334fc 100644 --- a/freqtrade/strategy/interface.py +++ b/freqtrade/strategy/interface.py @@ -32,20 +32,20 @@ logger = logging.getLogger(__name__) CUSTOM_EXIT_MAX_LENGTH = 64 -class SellCheckTuple: +class ExitCheckTuple: """ - NamedTuple for Sell type + reason + NamedTuple for Exit type + reason """ - sell_type: SellType - sell_reason: str = '' + exit_type: SellType + exit_reason: str = '' - def __init__(self, sell_type: SellType, sell_reason: str = ''): - self.sell_type = sell_type - self.sell_reason = sell_reason or sell_type.value + def __init__(self, exit_type: SellType, exit_reason: str = ''): + self.exit_type = exit_type + self.exit_reason = exit_reason or exit_type.value @property - def sell_flag(self): - return self.sell_type != SellType.NONE + def exit_flag(self): + return self.exit_type != SellType.NONE class IStrategy(ABC, HyperStrategyMixin): @@ -848,7 +848,7 @@ class IStrategy(ABC, HyperStrategyMixin): def should_exit(self, trade: Trade, rate: float, current_time: datetime, *, enter: bool, exit_: bool, low: float = None, high: float = None, - force_stoploss: float = 0) -> SellCheckTuple: + force_stoploss: float = 0) -> ExitCheckTuple: """ This function evaluates if one of the conditions required to trigger an exit order has been reached, which can either be a stop-loss, ROI or exit-signal. @@ -908,29 +908,29 @@ class IStrategy(ABC, HyperStrategyMixin): logger.debug(f"{trade.pair} - Sell signal received. " f"sell_type=SellType.{sell_signal.name}" + (f", custom_reason={custom_reason}" if custom_reason else "")) - return SellCheckTuple(sell_type=sell_signal, sell_reason=custom_reason) + return ExitCheckTuple(exit_type=sell_signal, exit_reason=custom_reason) # Sequence: # Exit-signal # ROI (if not stoploss) # Stoploss - if roi_reached and stoplossflag.sell_type != SellType.STOP_LOSS: + if roi_reached and stoplossflag.exit_type != SellType.STOP_LOSS: logger.debug(f"{trade.pair} - Required profit reached. sell_type=SellType.ROI") - return SellCheckTuple(sell_type=SellType.ROI) + return ExitCheckTuple(exit_type=SellType.ROI) - if stoplossflag.sell_flag: + if stoplossflag.exit_flag: - logger.debug(f"{trade.pair} - Stoploss hit. sell_type={stoplossflag.sell_type}") + logger.debug(f"{trade.pair} - Stoploss hit. sell_type={stoplossflag.exit_type}") return stoplossflag # This one is noisy, commented out... # logger.debug(f"{trade.pair} - No exit signal.") - return SellCheckTuple(sell_type=SellType.NONE) + return ExitCheckTuple(exit_type=SellType.NONE) def stop_loss_reached(self, current_rate: float, trade: Trade, current_time: datetime, current_profit: float, force_stoploss: float, low: float = None, - high: float = None) -> SellCheckTuple: + high: float = None) -> ExitCheckTuple: """ Based on current profit of the trade and configured (trailing) stoploss, decides to exit or not @@ -1008,9 +1008,9 @@ class IStrategy(ABC, HyperStrategyMixin): logger.debug(f"{trade.pair} - Trailing stop saved " f"{new_stoploss:.6f}") - return SellCheckTuple(sell_type=sell_type) + return ExitCheckTuple(exit_type=sell_type) - return SellCheckTuple(sell_type=SellType.NONE) + return ExitCheckTuple(exit_type=SellType.NONE) def min_roi_reached_entry(self, trade_dur: int) -> Tuple[Optional[int], Optional[float]]: """ diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py index 18af215a3..3d75b36ac 100644 --- a/tests/strategy/test_interface.py +++ b/tests/strategy/test_interface.py @@ -18,7 +18,7 @@ from freqtrade.persistence import PairLocks, Trade from freqtrade.resolvers import StrategyResolver from freqtrade.strategy.hyper import (BaseParameter, BooleanParameter, CategoricalParameter, DecimalParameter, IntParameter, RealParameter) -from freqtrade.strategy.interface import SellCheckTuple +from freqtrade.strategy.interface import ExitCheckTuple from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper from tests.conftest import CURRENT_TEST_STRATEGY, TRADE_SIDES, log_has, log_has_re @@ -455,23 +455,23 @@ def test_stop_loss_reached(default_conf, fee, profit, adjusted, expected, traili sl_flag = strategy.stop_loss_reached(current_rate=current_rate, trade=trade, current_time=now, current_profit=profit, force_stoploss=0, high=None) - assert isinstance(sl_flag, SellCheckTuple) - assert sl_flag.sell_type == expected + assert isinstance(sl_flag, ExitCheckTuple) + assert sl_flag.exit_type == expected if expected == SellType.NONE: - assert sl_flag.sell_flag is False + assert sl_flag.exit_flag is False else: - assert sl_flag.sell_flag is True + assert sl_flag.exit_flag is True assert round(trade.stop_loss, 2) == adjusted current_rate2 = trade.open_rate * (1 + profit2) sl_flag = strategy.stop_loss_reached(current_rate=current_rate2, trade=trade, current_time=now, current_profit=profit2, force_stoploss=0, high=None) - assert sl_flag.sell_type == expected2 + assert sl_flag.exit_type == expected2 if expected2 == SellType.NONE: - assert sl_flag.sell_flag is False + assert sl_flag.exit_flag is False else: - assert sl_flag.sell_flag is True + assert sl_flag.exit_flag is True assert round(trade.stop_loss, 2) == adjusted2 strategy.custom_stoploss = original_stopvalue @@ -496,34 +496,34 @@ def test_custom_exit(default_conf, fee, caplog) -> None: enter=False, exit_=False, low=None, high=None) - assert res.sell_flag is False - assert res.sell_type == SellType.NONE + assert res.exit_flag is False + assert res.exit_type == SellType.NONE strategy.custom_exit = MagicMock(return_value=True) res = strategy.should_exit(trade, 1, now, enter=False, exit_=False, low=None, high=None) - assert res.sell_flag is True - assert res.sell_type == SellType.CUSTOM_SELL - assert res.sell_reason == 'custom_sell' + assert res.exit_flag is True + assert res.exit_type == SellType.CUSTOM_SELL + assert res.exit_reason == 'custom_sell' strategy.custom_exit = MagicMock(return_value='hello world') res = strategy.should_exit(trade, 1, now, enter=False, exit_=False, low=None, high=None) - assert res.sell_type == SellType.CUSTOM_SELL - assert res.sell_flag is True - assert res.sell_reason == 'hello world' + assert res.exit_type == SellType.CUSTOM_SELL + assert res.exit_flag is True + assert res.exit_reason == 'hello world' caplog.clear() strategy.custom_exit = MagicMock(return_value='h' * 100) res = strategy.should_exit(trade, 1, now, enter=False, exit_=False, low=None, high=None) - assert res.sell_type == SellType.CUSTOM_SELL - assert res.sell_flag is True - assert res.sell_reason == 'h' * 64 + assert res.exit_type == SellType.CUSTOM_SELL + assert res.exit_flag is True + assert res.exit_reason == 'h' * 64 assert log_has_re('Custom sell reason returned from custom_exit is too long.*', caplog) diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py index feed74a49..6f7b8f9b0 100644 --- a/tests/test_freqtradebot.py +++ b/tests/test_freqtradebot.py @@ -20,7 +20,7 @@ from freqtrade.exceptions import (DependencyException, ExchangeError, Insufficie from freqtrade.freqtradebot import FreqtradeBot from freqtrade.persistence import Order, PairLocks, Trade from freqtrade.persistence.models import PairLock -from freqtrade.strategy.interface import SellCheckTuple +from freqtrade.strategy.interface import ExitCheckTuple from freqtrade.worker import Worker from tests.conftest import (create_mock_trades, get_patched_freqtradebot, get_patched_worker, log_has, log_has_re, patch_edge, patch_exchange, patch_get_signal, @@ -3100,7 +3100,7 @@ def test_execute_trade_exit_up(default_conf_usdt, ticker_usdt, fee, ticker_usdt_ freqtrade.execute_trade_exit( trade=trade, limit=(ticker_usdt_sell_down()['ask'] if is_short else ticker_usdt_sell_up()['bid']), - exit_check=SellCheckTuple(sell_type=SellType.ROI) + exit_check=ExitCheckTuple(exit_type=SellType.ROI) ) assert rpc_mock.call_count == 0 assert freqtrade.strategy.confirm_trade_exit.call_count == 1 @@ -3112,7 +3112,7 @@ def test_execute_trade_exit_up(default_conf_usdt, ticker_usdt, fee, ticker_usdt_ freqtrade.execute_trade_exit( trade=trade, limit=(ticker_usdt_sell_down()['ask'] if is_short else ticker_usdt_sell_up()['bid']), - exit_check=SellCheckTuple(sell_type=SellType.ROI) + exit_check=ExitCheckTuple(exit_type=SellType.ROI) ) assert freqtrade.strategy.confirm_trade_exit.call_count == 1 @@ -3173,7 +3173,7 @@ def test_execute_trade_exit_down(default_conf_usdt, ticker_usdt, fee, ticker_usd ) freqtrade.execute_trade_exit( trade=trade, limit=(ticker_usdt_sell_up if is_short else ticker_usdt_sell_down)()['bid'], - exit_check=SellCheckTuple(sell_type=SellType.STOP_LOSS)) + exit_check=ExitCheckTuple(exit_type=SellType.STOP_LOSS)) assert rpc_mock.call_count == 2 last_msg = rpc_mock.call_args_list[-1][0][0] @@ -3248,7 +3248,7 @@ def test_execute_trade_exit_custom_exit_price( freqtrade.execute_trade_exit( trade=trade, limit=ticker_usdt_sell_up()['ask' if is_short else 'bid'], - exit_check=SellCheckTuple(sell_type=SellType.SELL_SIGNAL) + exit_check=ExitCheckTuple(exit_type=SellType.SELL_SIGNAL) ) # Sell price must be different to default bid price @@ -3319,7 +3319,7 @@ def test_execute_trade_exit_down_stoploss_on_exchange_dry_run( trade.stop_loss = 2.0 * 1.01 if is_short else 2.0 * 0.99 freqtrade.execute_trade_exit( trade=trade, limit=(ticker_usdt_sell_up if is_short else ticker_usdt_sell_down())['bid'], - exit_check=SellCheckTuple(sell_type=SellType.STOP_LOSS)) + exit_check=ExitCheckTuple(exit_type=SellType.STOP_LOSS)) assert rpc_mock.call_count == 2 last_msg = rpc_mock.call_args_list[-1][0][0] @@ -3379,7 +3379,7 @@ def test_execute_trade_exit_sloe_cancel_exception( trade.stoploss_order_id = "abcd" freqtrade.execute_trade_exit(trade=trade, limit=1234, - exit_check=SellCheckTuple(sell_type=SellType.STOP_LOSS)) + exit_check=ExitCheckTuple(exit_type=SellType.STOP_LOSS)) assert create_order_mock.call_count == 2 assert log_has('Could not cancel stoploss order abcd', caplog) @@ -3434,7 +3434,7 @@ def test_execute_trade_exit_with_stoploss_on_exchange( freqtrade.execute_trade_exit( trade=trade, limit=ticker_usdt_sell_up()['ask' if is_short else 'bid'], - exit_check=SellCheckTuple(sell_type=SellType.STOP_LOSS) + exit_check=ExitCheckTuple(exit_type=SellType.STOP_LOSS) ) trade = Trade.query.first() @@ -3579,7 +3579,7 @@ def test_execute_trade_exit_market_order( freqtrade.execute_trade_exit( trade=trade, limit=ticker_usdt_sell_up()['ask' if is_short else 'bid'], - exit_check=SellCheckTuple(sell_type=SellType.ROI) + exit_check=ExitCheckTuple(exit_type=SellType.ROI) ) assert not trade.is_open @@ -3643,7 +3643,7 @@ def test_execute_trade_exit_insufficient_funds_error(default_conf_usdt, ticker_u fetch_ticker=ticker_usdt_sell_up ) - sell_reason = SellCheckTuple(sell_type=SellType.ROI) + sell_reason = ExitCheckTuple(exit_type=SellType.ROI) assert not freqtrade.execute_trade_exit( trade=trade, limit=ticker_usdt_sell_up()['ask' if is_short else 'bid'], @@ -3696,8 +3696,8 @@ def test_sell_profit_only( if sell_type == SellType.SELL_SIGNAL.value: freqtrade.strategy.min_roi_reached = MagicMock(return_value=False) else: - freqtrade.strategy.stop_loss_reached = MagicMock(return_value=SellCheckTuple( - sell_type=SellType.NONE)) + freqtrade.strategy.stop_loss_reached = MagicMock(return_value=ExitCheckTuple( + exit_type=SellType.NONE)) freqtrade.enter_positions() trade = Trade.query.first() @@ -3816,7 +3816,7 @@ def test_locked_pairs(default_conf_usdt, ticker_usdt, fee, freqtrade.execute_trade_exit( trade=trade, limit=ticker_usdt_sell_down()['ask' if is_short else 'bid'], - exit_check=SellCheckTuple(sell_type=SellType.STOP_LOSS) + exit_check=ExitCheckTuple(exit_type=SellType.STOP_LOSS) ) trade.close(ticker_usdt_sell_down()['bid']) assert freqtrade.strategy.is_pair_locked(trade.pair) @@ -5145,7 +5145,7 @@ def test_update_funding_fees( trade=trade, # The values of the next 2 params are irrelevant for this test limit=ticker_usdt_sell_up()['bid'], - exit_check=SellCheckTuple(sell_type=SellType.ROI) + exit_check=ExitCheckTuple(exit_type=SellType.ROI) ) assert trade.funding_fees == pytest.approx(sum( trade.amount * diff --git a/tests/test_integration.py b/tests/test_integration.py index 9115b431b..3e9c81a80 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -6,7 +6,7 @@ from freqtrade.enums import SellType from freqtrade.persistence import Trade from freqtrade.persistence.models import Order from freqtrade.rpc.rpc import RPC -from freqtrade.strategy.interface import SellCheckTuple +from freqtrade.strategy.interface import ExitCheckTuple from tests.conftest import get_patched_freqtradebot, patch_get_signal @@ -53,8 +53,8 @@ def test_may_execute_exit_stoploss_on_exchange_multi(default_conf, ticker, fee, side_effect=[stoploss_order_closed, stoploss_order_open, stoploss_order_open]) # Sell 3rd trade (not called for the first trade) should_sell_mock = MagicMock(side_effect=[ - SellCheckTuple(sell_type=SellType.NONE), - SellCheckTuple(sell_type=SellType.SELL_SIGNAL)] + ExitCheckTuple(exit_type=SellType.NONE), + ExitCheckTuple(exit_type=SellType.SELL_SIGNAL)] ) cancel_order_mock = MagicMock() mocker.patch('freqtrade.exchange.Binance.stoploss', stoploss) @@ -161,11 +161,11 @@ def test_forcebuy_last_unlimited(default_conf, ticker, fee, mocker, balance_rati _notify_exit=MagicMock(), ) should_sell_mock = MagicMock(side_effect=[ - SellCheckTuple(sell_type=SellType.NONE), - SellCheckTuple(sell_type=SellType.SELL_SIGNAL), - SellCheckTuple(sell_type=SellType.NONE), - SellCheckTuple(sell_type=SellType.NONE), - SellCheckTuple(sell_type=SellType.NONE)] + ExitCheckTuple(exit_type=SellType.NONE), + ExitCheckTuple(exit_type=SellType.SELL_SIGNAL), + ExitCheckTuple(exit_type=SellType.NONE), + ExitCheckTuple(exit_type=SellType.NONE), + ExitCheckTuple(exit_type=SellType.NONE)] ) mocker.patch("freqtrade.strategy.interface.IStrategy.should_exit", should_sell_mock)