From e2d52991165e3e427b9c2c351a61a235dd6efe6d Mon Sep 17 00:00:00 2001 From: Sam Germain Date: Wed, 18 Aug 2021 06:03:44 -0600 Subject: [PATCH 1/3] Name changes for strategy --- freqtrade/optimize/backtesting.py | 7 +- freqtrade/optimize/hyperopt.py | 6 +- freqtrade/resolvers/strategy_resolver.py | 20 +++--- freqtrade/strategy/interface.py | 67 ++++++++++-------- freqtrade/strategy/strategy_helper.py | 7 +- freqtrade/templates/sample_hyperopt.py | 70 ++++++++++--------- .../templates/sample_hyperopt_advanced.py | 61 ++++++++-------- tests/optimize/hyperopts/default_hyperopt.py | 23 +++--- .../strategy/strats/hyperoptable_strategy.py | 2 +- tests/strategy/test_interface.py | 20 +++--- tests/strategy/test_strategy_loading.py | 24 +++---- 11 files changed, 174 insertions(+), 133 deletions(-) diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py index 3079e326d..cce3b6a0d 100644 --- a/freqtrade/optimize/backtesting.py +++ b/freqtrade/optimize/backtesting.py @@ -232,7 +232,12 @@ class Backtesting: pair_data.loc[:, 'buy_tag'] = None # cleanup if buy_tag is exist df_analyzed = self.strategy.advise_sell( - self.strategy.advise_buy(pair_data, {'pair': pair}), {'pair': pair}).copy() + self.strategy.advise_buy( + pair_data, + {'pair': pair} + ), + {'pair': pair} + ).copy() # Trim startup period from analyzed dataframe df_analyzed = trim_dataframe(df_analyzed, self.timerange, startup_candles=self.required_startup) diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py index 0db78aa39..5c627df35 100644 --- a/freqtrade/optimize/hyperopt.py +++ b/freqtrade/optimize/hyperopt.py @@ -285,11 +285,13 @@ class Hyperopt: # Apply parameters if HyperoptTools.has_space(self.config, 'buy'): self.backtesting.strategy.advise_buy = ( # type: ignore - self.custom_hyperopt.buy_strategy_generator(params_dict)) + self.custom_hyperopt.buy_strategy_generator(params_dict) + ) if HyperoptTools.has_space(self.config, 'sell'): self.backtesting.strategy.advise_sell = ( # type: ignore - self.custom_hyperopt.sell_strategy_generator(params_dict)) + self.custom_hyperopt.sell_strategy_generator(params_dict) + ) if HyperoptTools.has_space(self.config, 'protection'): for attr_name, attr in self.backtesting.strategy.enumerate_parameters('protection'): diff --git a/freqtrade/resolvers/strategy_resolver.py b/freqtrade/resolvers/strategy_resolver.py index e7c077e84..0d1f1598f 100644 --- a/freqtrade/resolvers/strategy_resolver.py +++ b/freqtrade/resolvers/strategy_resolver.py @@ -193,18 +193,22 @@ class StrategyResolver(IResolver): # register temp path with the bot abs_paths.insert(0, temp.resolve()) - strategy = StrategyResolver._load_object(paths=abs_paths, - object_name=strategy_name, - add_source=True, - kwargs={'config': config}, - ) + strategy = StrategyResolver._load_object( + paths=abs_paths, + object_name=strategy_name, + add_source=True, + kwargs={'config': config}, + ) + if strategy: strategy._populate_fun_len = len(getfullargspec(strategy.populate_indicators).args) strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args) strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args) - if any(x == 2 for x in [strategy._populate_fun_len, - strategy._buy_fun_len, - strategy._sell_fun_len]): + if any(x == 2 for x in [ + strategy._populate_fun_len, + strategy._buy_fun_len, + strategy._sell_fun_len + ]): strategy.INTERFACE_VERSION = 1 return strategy diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py index bf5cc10af..f78846da3 100644 --- a/freqtrade/strategy/interface.py +++ b/freqtrade/strategy/interface.py @@ -242,13 +242,13 @@ class IStrategy(ABC, HyperStrategyMixin): When not implemented by a strategy, returns True (always confirming). - :param pair: Pair that's about to be sold. + :param pair: Pair for trade that's about to be exited. :param trade: trade object. :param order_type: Order type (as configured in order_types). usually limit or market. :param amount: Amount in quote currency. :param rate: Rate that's going to be used when using limit orders :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled). - :param sell_reason: Sell reason. + :param sell_reason: Exit reason. Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss', 'sell_signal', 'force_sell', 'emergency_sell'] :param current_time: datetime object, containing the current datetime @@ -283,15 +283,15 @@ class IStrategy(ABC, HyperStrategyMixin): def custom_sell(self, pair: str, trade: Trade, current_time: datetime, current_rate: float, current_profit: float, **kwargs) -> Optional[Union[str, bool]]: """ - Custom sell signal logic indicating that specified position should be sold. Returning a - string or True from this method is equal to setting sell signal on a candle at specified - time. This method is not called when sell signal is set. + Custom exit signal logic indicating that specified position should be sold. Returning a + string or True from this method is equal to setting exit signal on a candle at specified + time. This method is not called when exit signal is set. - This method should be overridden to create sell signals that depend on trade parameters. For - example you could implement a sell relative to the candle when the trade was opened, + This method should be overridden to create exit signals that depend on trade parameters. For + example you could implement an exit relative to the candle when the trade was opened, or a custom 1:2 risk-reward ROI. - Custom sell reason max length is 64. Exceeding characters will be removed. + Custom exit reason max length is 64. Exceeding characters will be removed. :param pair: Pair that's currently analyzed :param trade: trade object. @@ -299,7 +299,7 @@ class IStrategy(ABC, HyperStrategyMixin): :param current_rate: Rate, calculated based on pricing settings in ask_strategy. :param current_profit: Current profit (as ratio), calculated based on current_rate. :param **kwargs: Ensure to keep this here so updates to this won't break your strategy. - :return: To execute sell, return a string with custom sell reason or True. Otherwise return + :return: To execute exit, return a string with custom sell reason or True. Otherwise return None or False. """ return None @@ -528,27 +528,34 @@ class IStrategy(ABC, HyperStrategyMixin): ) return False, False, None - buy = latest[SignalType.BUY.value] == 1 + enter = latest[SignalType.BUY.value] == 1 - sell = False + exit = False if SignalType.SELL.value in latest: - sell = latest[SignalType.SELL.value] == 1 + exit = latest[SignalType.SELL.value] == 1 buy_tag = latest.get(SignalTagType.BUY_TAG.value, None) logger.debug('trigger: %s (pair=%s) buy=%s sell=%s', - latest['date'], pair, str(buy), str(sell)) + latest['date'], pair, str(enter), str(exit)) timeframe_seconds = timeframe_to_seconds(timeframe) - if self.ignore_expired_candle(latest_date=latest_date, - current_time=datetime.now(timezone.utc), - timeframe_seconds=timeframe_seconds, - buy=buy): - return False, sell, buy_tag - return buy, sell, buy_tag + if self.ignore_expired_candle( + latest_date=latest_date, + current_time=datetime.now(timezone.utc), + timeframe_seconds=timeframe_seconds, + enter=enter + ): + return False, exit, buy_tag + return enter, exit, buy_tag - def ignore_expired_candle(self, latest_date: datetime, current_time: datetime, - timeframe_seconds: int, buy: bool): - if self.ignore_buying_expired_candle_after and buy: + def ignore_expired_candle( + self, + latest_date: datetime, + current_time: datetime, + timeframe_seconds: int, + enter: bool + ): + if self.ignore_buying_expired_candle_after and enter: time_delta = current_time - (latest_date + timedelta(seconds=timeframe_seconds)) return time_delta.total_seconds() > self.ignore_buying_expired_candle_after else: @@ -559,7 +566,7 @@ class IStrategy(ABC, HyperStrategyMixin): force_stoploss: float = 0) -> SellCheckTuple: """ This function evaluates if one of the conditions required to trigger a sell - has been reached, which can either be a stop-loss, ROI or sell-signal. + has been reached, which can either be a stop-loss, ROI or exit-signal. :param low: Only used during backtesting to simulate stoploss :param high: Only used during backtesting, to simulate ROI :param force_stoploss: Externally provided stoploss @@ -578,7 +585,7 @@ class IStrategy(ABC, HyperStrategyMixin): current_rate = high or rate current_profit = trade.calc_profit_ratio(current_rate) - # if buy signal and ignore_roi is set, we don't need to evaluate min_roi. + # if enter signal and ignore_roi is set, we don't need to evaluate min_roi. roi_reached = (not (buy and self.ignore_roi_if_buy_signal) and self.min_roi_reached(trade=trade, current_profit=current_profit, current_time=date)) @@ -609,12 +616,12 @@ class IStrategy(ABC, HyperStrategyMixin): custom_reason = custom_reason[:CUSTOM_SELL_MAX_LENGTH] else: custom_reason = None - # TODO: return here if sell-signal should be favored over ROI + # TODO: return here if exit-signal should be favored over ROI # Start evaluations # Sequence: # ROI (if not stoploss) - # Sell-signal + # Exit-signal # Stoploss if roi_reached and stoplossflag.sell_type != SellType.STOP_LOSS: logger.debug(f"{trade.pair} - Required profit reached. sell_type=SellType.ROI") @@ -632,7 +639,7 @@ class IStrategy(ABC, HyperStrategyMixin): return stoplossflag # This one is noisy, commented out... - # logger.debug(f"{trade.pair} - No sell signal.") + # logger.debug(f"{trade.pair} - No exit signal.") return SellCheckTuple(sell_type=SellType.NONE) def stop_loss_reached(self, current_rate: float, trade: Trade, @@ -769,7 +776,8 @@ class IStrategy(ABC, HyperStrategyMixin): currently traded pair :return: DataFrame with buy column """ - logger.debug(f"Populating buy signals for pair {metadata.get('pair')}.") + + logger.debug(f"Populating enter signals for pair {metadata.get('pair')}.") if self._buy_fun_len == 2: warnings.warn("deprecated - check out the Sample strategy to see " @@ -787,7 +795,8 @@ class IStrategy(ABC, HyperStrategyMixin): currently traded pair :return: DataFrame with sell column """ - logger.debug(f"Populating sell signals for pair {metadata.get('pair')}.") + + logger.debug(f"Populating exit signals for pair {metadata.get('pair')}.") if self._sell_fun_len == 2: warnings.warn("deprecated - check out the Sample strategy to see " "the current function headers!", DeprecationWarning) diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py index e089ebf31..36f284402 100644 --- a/freqtrade/strategy/strategy_helper.py +++ b/freqtrade/strategy/strategy_helper.py @@ -58,7 +58,10 @@ def merge_informative_pair(dataframe: pd.DataFrame, informative: pd.DataFrame, return dataframe -def stoploss_from_open(open_relative_stop: float, current_profit: float) -> float: +def stoploss_from_open( + open_relative_stop: float, + current_profit: float +) -> float: """ Given the current profit, and a desired stop loss value relative to the open price, @@ -72,7 +75,7 @@ def stoploss_from_open(open_relative_stop: float, current_profit: float) -> floa :param open_relative_stop: Desired stop loss percentage relative to open price :param current_profit: The current profit percentage - :return: Positive stop loss value relative to current price + :return: Stop loss value relative to current price """ # formula is undefined for current_profit -1, return maximum value diff --git a/freqtrade/templates/sample_hyperopt.py b/freqtrade/templates/sample_hyperopt.py index ed1af7718..6e15b436d 100644 --- a/freqtrade/templates/sample_hyperopt.py +++ b/freqtrade/templates/sample_hyperopt.py @@ -46,7 +46,7 @@ class SampleHyperOpt(IHyperOpt): """ @staticmethod - def indicator_space() -> List[Dimension]: + def buy_indicator_space() -> List[Dimension]: """ Define your Hyperopt space for searching buy strategy parameters. """ @@ -59,7 +59,7 @@ class SampleHyperOpt(IHyperOpt): Categorical([True, False], name='fastd-enabled'), Categorical([True, False], name='adx-enabled'), Categorical([True, False], name='rsi-enabled'), - Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger') + Categorical(['boll', 'macd_cross_signal', 'sar_reversal'], name='trigger') ] @staticmethod @@ -71,37 +71,39 @@ class SampleHyperOpt(IHyperOpt): """ Buy strategy Hyperopt will build and use. """ - conditions = [] + long_conditions = [] # GUARDS AND TRENDS if 'mfi-enabled' in params and params['mfi-enabled']: - conditions.append(dataframe['mfi'] < params['mfi-value']) + long_conditions.append(dataframe['mfi'] < params['mfi-value']) if 'fastd-enabled' in params and params['fastd-enabled']: - conditions.append(dataframe['fastd'] < params['fastd-value']) + long_conditions.append(dataframe['fastd'] < params['fastd-value']) if 'adx-enabled' in params and params['adx-enabled']: - conditions.append(dataframe['adx'] > params['adx-value']) + long_conditions.append(dataframe['adx'] > params['adx-value']) if 'rsi-enabled' in params and params['rsi-enabled']: - conditions.append(dataframe['rsi'] < params['rsi-value']) + long_conditions.append(dataframe['rsi'] < params['rsi-value']) # TRIGGERS if 'trigger' in params: - if params['trigger'] == 'bb_lower': - conditions.append(dataframe['close'] < dataframe['bb_lowerband']) + if params['trigger'] == 'boll': + long_conditions.append(dataframe['close'] < dataframe['bb_lowerband']) if params['trigger'] == 'macd_cross_signal': - conditions.append(qtpylib.crossed_above( - dataframe['macd'], dataframe['macdsignal'] + long_conditions.append(qtpylib.crossed_above( + dataframe['macd'], + dataframe['macdsignal'] )) if params['trigger'] == 'sar_reversal': - conditions.append(qtpylib.crossed_above( - dataframe['close'], dataframe['sar'] + long_conditions.append(qtpylib.crossed_above( + dataframe['close'], + dataframe['sar'] )) # Check that volume is not 0 - conditions.append(dataframe['volume'] > 0) + long_conditions.append(dataframe['volume'] > 0) - if conditions: + if long_conditions: dataframe.loc[ - reduce(lambda x, y: x & y, conditions), + reduce(lambda x, y: x & y, long_conditions), 'buy'] = 1 return dataframe @@ -122,9 +124,11 @@ class SampleHyperOpt(IHyperOpt): Categorical([True, False], name='sell-fastd-enabled'), Categorical([True, False], name='sell-adx-enabled'), Categorical([True, False], name='sell-rsi-enabled'), - Categorical(['sell-bb_upper', + Categorical(['sell-boll', 'sell-macd_cross_signal', - 'sell-sar_reversal'], name='sell-trigger') + 'sell-sar_reversal'], + name='sell-trigger' + ) ] @staticmethod @@ -136,37 +140,39 @@ class SampleHyperOpt(IHyperOpt): """ Sell strategy Hyperopt will build and use. """ - conditions = [] + exit_long_conditions = [] # GUARDS AND TRENDS if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']: - conditions.append(dataframe['mfi'] > params['sell-mfi-value']) + exit_long_conditions.append(dataframe['mfi'] > params['sell-mfi-value']) if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']: - conditions.append(dataframe['fastd'] > params['sell-fastd-value']) + exit_long_conditions.append(dataframe['fastd'] > params['sell-fastd-value']) if 'sell-adx-enabled' in params and params['sell-adx-enabled']: - conditions.append(dataframe['adx'] < params['sell-adx-value']) + exit_long_conditions.append(dataframe['adx'] < params['sell-adx-value']) if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']: - conditions.append(dataframe['rsi'] > params['sell-rsi-value']) + exit_long_conditions.append(dataframe['rsi'] > params['sell-rsi-value']) # TRIGGERS if 'sell-trigger' in params: - if params['sell-trigger'] == 'sell-bb_upper': - conditions.append(dataframe['close'] > dataframe['bb_upperband']) + if params['sell-trigger'] == 'sell-boll': + exit_long_conditions.append(dataframe['close'] > dataframe['bb_upperband']) if params['sell-trigger'] == 'sell-macd_cross_signal': - conditions.append(qtpylib.crossed_above( - dataframe['macdsignal'], dataframe['macd'] + exit_long_conditions.append(qtpylib.crossed_above( + dataframe['macdsignal'], + dataframe['macd'] )) if params['sell-trigger'] == 'sell-sar_reversal': - conditions.append(qtpylib.crossed_above( - dataframe['sar'], dataframe['close'] + exit_long_conditions.append(qtpylib.crossed_above( + dataframe['sar'], + dataframe['close'] )) # Check that volume is not 0 - conditions.append(dataframe['volume'] > 0) + exit_long_conditions.append(dataframe['volume'] > 0) - if conditions: + if exit_long_conditions: dataframe.loc[ - reduce(lambda x, y: x & y, conditions), + reduce(lambda x, y: x & y, exit_long_conditions), 'sell'] = 1 return dataframe diff --git a/freqtrade/templates/sample_hyperopt_advanced.py b/freqtrade/templates/sample_hyperopt_advanced.py index cc13b6ba3..733f1ef3e 100644 --- a/freqtrade/templates/sample_hyperopt_advanced.py +++ b/freqtrade/templates/sample_hyperopt_advanced.py @@ -74,7 +74,7 @@ class AdvancedSampleHyperOpt(IHyperOpt): Categorical([True, False], name='fastd-enabled'), Categorical([True, False], name='adx-enabled'), Categorical([True, False], name='rsi-enabled'), - Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger') + Categorical(['boll', 'macd_cross_signal', 'sar_reversal'], name='trigger') ] @staticmethod @@ -86,36 +86,36 @@ class AdvancedSampleHyperOpt(IHyperOpt): """ Buy strategy Hyperopt will build and use """ - conditions = [] + long_conditions = [] # GUARDS AND TRENDS if 'mfi-enabled' in params and params['mfi-enabled']: - conditions.append(dataframe['mfi'] < params['mfi-value']) + long_conditions.append(dataframe['mfi'] < params['mfi-value']) if 'fastd-enabled' in params and params['fastd-enabled']: - conditions.append(dataframe['fastd'] < params['fastd-value']) + long_conditions.append(dataframe['fastd'] < params['fastd-value']) if 'adx-enabled' in params and params['adx-enabled']: - conditions.append(dataframe['adx'] > params['adx-value']) + long_conditions.append(dataframe['adx'] > params['adx-value']) if 'rsi-enabled' in params and params['rsi-enabled']: - conditions.append(dataframe['rsi'] < params['rsi-value']) + long_conditions.append(dataframe['rsi'] < params['rsi-value']) # TRIGGERS if 'trigger' in params: - if params['trigger'] == 'bb_lower': - conditions.append(dataframe['close'] < dataframe['bb_lowerband']) + if params['trigger'] == 'boll': + long_conditions.append(dataframe['close'] < dataframe['bb_lowerband']) if params['trigger'] == 'macd_cross_signal': - conditions.append(qtpylib.crossed_above( + long_conditions.append(qtpylib.crossed_above( dataframe['macd'], dataframe['macdsignal'] )) if params['trigger'] == 'sar_reversal': - conditions.append(qtpylib.crossed_above( + long_conditions.append(qtpylib.crossed_above( dataframe['close'], dataframe['sar'] )) # Check that volume is not 0 - conditions.append(dataframe['volume'] > 0) + long_conditions.append(dataframe['volume'] > 0) - if conditions: + if long_conditions: dataframe.loc[ - reduce(lambda x, y: x & y, conditions), + reduce(lambda x, y: x & y, long_conditions), 'buy'] = 1 return dataframe @@ -136,9 +136,10 @@ class AdvancedSampleHyperOpt(IHyperOpt): Categorical([True, False], name='sell-fastd-enabled'), Categorical([True, False], name='sell-adx-enabled'), Categorical([True, False], name='sell-rsi-enabled'), - Categorical(['sell-bb_upper', + Categorical(['sell-boll', 'sell-macd_cross_signal', - 'sell-sar_reversal'], name='sell-trigger') + 'sell-sar_reversal'], + name='sell-trigger') ] @staticmethod @@ -151,36 +152,38 @@ class AdvancedSampleHyperOpt(IHyperOpt): Sell strategy Hyperopt will build and use """ # print(params) - conditions = [] + exit_long_conditions = [] # GUARDS AND TRENDS if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']: - conditions.append(dataframe['mfi'] > params['sell-mfi-value']) + exit_long_conditions.append(dataframe['mfi'] > params['sell-mfi-value']) if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']: - conditions.append(dataframe['fastd'] > params['sell-fastd-value']) + exit_long_conditions.append(dataframe['fastd'] > params['sell-fastd-value']) if 'sell-adx-enabled' in params and params['sell-adx-enabled']: - conditions.append(dataframe['adx'] < params['sell-adx-value']) + exit_long_conditions.append(dataframe['adx'] < params['sell-adx-value']) if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']: - conditions.append(dataframe['rsi'] > params['sell-rsi-value']) + exit_long_conditions.append(dataframe['rsi'] > params['sell-rsi-value']) # TRIGGERS if 'sell-trigger' in params: - if params['sell-trigger'] == 'sell-bb_upper': - conditions.append(dataframe['close'] > dataframe['bb_upperband']) + if params['sell-trigger'] == 'sell-boll': + exit_long_conditions.append(dataframe['close'] > dataframe['bb_upperband']) if params['sell-trigger'] == 'sell-macd_cross_signal': - conditions.append(qtpylib.crossed_above( - dataframe['macdsignal'], dataframe['macd'] + exit_long_conditions.append(qtpylib.crossed_above( + dataframe['macdsignal'], + dataframe['macd'] )) if params['sell-trigger'] == 'sell-sar_reversal': - conditions.append(qtpylib.crossed_above( - dataframe['sar'], dataframe['close'] + exit_long_conditions.append(qtpylib.crossed_above( + dataframe['sar'], + dataframe['close'] )) # Check that volume is not 0 - conditions.append(dataframe['volume'] > 0) + exit_long_conditions.append(dataframe['volume'] > 0) - if conditions: + if exit_long_conditions: dataframe.loc[ - reduce(lambda x, y: x & y, conditions), + reduce(lambda x, y: x & y, exit_long_conditions), 'sell'] = 1 return dataframe diff --git a/tests/optimize/hyperopts/default_hyperopt.py b/tests/optimize/hyperopts/default_hyperopt.py index 2e2bca3d0..4147f475c 100644 --- a/tests/optimize/hyperopts/default_hyperopt.py +++ b/tests/optimize/hyperopts/default_hyperopt.py @@ -68,15 +68,17 @@ class DefaultHyperOpt(IHyperOpt): # TRIGGERS if 'trigger' in params: - if params['trigger'] == 'bb_lower': + if params['trigger'] == 'boll': conditions.append(dataframe['close'] < dataframe['bb_lowerband']) if params['trigger'] == 'macd_cross_signal': conditions.append(qtpylib.crossed_above( - dataframe['macd'], dataframe['macdsignal'] + dataframe['macd'], + dataframe['macdsignal'] )) if params['trigger'] == 'sar_reversal': conditions.append(qtpylib.crossed_above( - dataframe['close'], dataframe['sar'] + dataframe['close'], + dataframe['sar'] )) if conditions: @@ -102,7 +104,7 @@ class DefaultHyperOpt(IHyperOpt): Categorical([True, False], name='fastd-enabled'), Categorical([True, False], name='adx-enabled'), Categorical([True, False], name='rsi-enabled'), - Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger') + Categorical(['boll', 'macd_cross_signal', 'sar_reversal'], name='trigger') ] @staticmethod @@ -128,15 +130,17 @@ class DefaultHyperOpt(IHyperOpt): # TRIGGERS if 'sell-trigger' in params: - if params['sell-trigger'] == 'sell-bb_upper': + if params['sell-trigger'] == 'sell-boll': conditions.append(dataframe['close'] > dataframe['bb_upperband']) if params['sell-trigger'] == 'sell-macd_cross_signal': conditions.append(qtpylib.crossed_above( - dataframe['macdsignal'], dataframe['macd'] + dataframe['macdsignal'], + dataframe['macd'] )) if params['sell-trigger'] == 'sell-sar_reversal': conditions.append(qtpylib.crossed_above( - dataframe['sar'], dataframe['close'] + dataframe['sar'], + dataframe['close'] )) if conditions: @@ -162,9 +166,10 @@ class DefaultHyperOpt(IHyperOpt): Categorical([True, False], name='sell-fastd-enabled'), Categorical([True, False], name='sell-adx-enabled'), Categorical([True, False], name='sell-rsi-enabled'), - Categorical(['sell-bb_upper', + Categorical(['sell-boll', 'sell-macd_cross_signal', - 'sell-sar_reversal'], name='sell-trigger') + 'sell-sar_reversal'], + name='sell-trigger') ] def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: diff --git a/tests/strategy/strats/hyperoptable_strategy.py b/tests/strategy/strats/hyperoptable_strategy.py index 88bdd078e..1126bd6cf 100644 --- a/tests/strategy/strats/hyperoptable_strategy.py +++ b/tests/strategy/strats/hyperoptable_strategy.py @@ -167,7 +167,7 @@ class HyperoptableStrategy(IStrategy): Based on TA indicators, populates the sell signal for the given dataframe :param dataframe: DataFrame :param metadata: Additional information, like the currently traded pair - :return: DataFrame with buy column + :return: DataFrame with sell column """ dataframe.loc[ ( diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py index 0ad6d6f32..5aa18c7db 100644 --- a/tests/strategy/test_interface.py +++ b/tests/strategy/test_interface.py @@ -156,17 +156,21 @@ def test_ignore_expired_candle(default_conf): # Add 1 candle length as the "latest date" defines candle open. current_time = latest_date + timedelta(seconds=80 + 300) - assert strategy.ignore_expired_candle(latest_date=latest_date, - current_time=current_time, - timeframe_seconds=300, - buy=True) is True + assert strategy.ignore_expired_candle( + latest_date=latest_date, + current_time=current_time, + timeframe_seconds=300, + enter=True + ) is True current_time = latest_date + timedelta(seconds=30 + 300) - assert not strategy.ignore_expired_candle(latest_date=latest_date, - current_time=current_time, - timeframe_seconds=300, - buy=True) is True + assert not strategy.ignore_expired_candle( + latest_date=latest_date, + current_time=current_time, + timeframe_seconds=300, + enter=True + ) is True def test_assert_df_raise(mocker, caplog, ohlcv_history): diff --git a/tests/strategy/test_strategy_loading.py b/tests/strategy/test_strategy_loading.py index 115a2fbde..e76990ba9 100644 --- a/tests/strategy/test_strategy_loading.py +++ b/tests/strategy/test_strategy_loading.py @@ -382,13 +382,13 @@ def test_call_deprecated_function(result, monkeypatch, default_conf, caplog): assert isinstance(indicator_df, DataFrame) assert 'adx' in indicator_df.columns - buydf = strategy.advise_buy(result, metadata=metadata) - assert isinstance(buydf, DataFrame) - assert 'buy' in buydf.columns + enterdf = strategy.advise_buy(result, metadata=metadata) + assert isinstance(enterdf, DataFrame) + assert 'buy' in enterdf.columns - selldf = strategy.advise_sell(result, metadata=metadata) - assert isinstance(selldf, DataFrame) - assert 'sell' in selldf + exitdf = strategy.advise_sell(result, metadata=metadata) + assert isinstance(exitdf, DataFrame) + assert 'sell' in exitdf assert log_has("DEPRECATED: Please migrate to using 'timeframe' instead of 'ticker_interval'.", caplog) @@ -409,10 +409,10 @@ def test_strategy_interface_versioning(result, monkeypatch, default_conf): assert isinstance(indicator_df, DataFrame) assert 'adx' in indicator_df.columns - buydf = strategy.advise_buy(result, metadata=metadata) - assert isinstance(buydf, DataFrame) - assert 'buy' in buydf.columns + enterdf = strategy.advise_buy(result, metadata=metadata) + assert isinstance(enterdf, DataFrame) + assert 'buy' in enterdf.columns - selldf = strategy.advise_sell(result, metadata=metadata) - assert isinstance(selldf, DataFrame) - assert 'sell' in selldf + exitdf = strategy.advise_sell(result, metadata=metadata) + assert isinstance(exitdf, DataFrame) + assert 'sell' in exitdf From 314359dd6eba0dbedb5fd0743f9f085d30e1980e Mon Sep 17 00:00:00 2001 From: Sam Germain Date: Wed, 18 Aug 2021 06:23:44 -0600 Subject: [PATCH 2/3] strategy interface changes to comments to mention shorting --- freqtrade/strategy/interface.py | 54 +++++++++++++++++---------------- 1 file changed, 28 insertions(+), 26 deletions(-) diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py index f78846da3..a36a6f082 100644 --- a/freqtrade/strategy/interface.py +++ b/freqtrade/strategy/interface.py @@ -135,7 +135,7 @@ class IStrategy(ABC, HyperStrategyMixin): @abstractmethod def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ - Populate indicators that will be used in the Buy and Sell strategy + Populate indicators that will be used in the Buy, Sell, Short, Exit_short strategy :param dataframe: DataFrame with data from the exchange :param metadata: Additional information, like the currently traded pair :return: a Dataframe with all mandatory indicators for the strategies @@ -164,9 +164,9 @@ class IStrategy(ABC, HyperStrategyMixin): def check_buy_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool: """ - Check buy timeout function callback. - This method can be used to override the buy-timeout. - It is called whenever a limit buy order has been created, + Check buy enter timeout function callback. + This method can be used to override the enter-timeout. + It is called whenever a limit buy/short order has been created, and is not yet fully filled. Configuration options in `unfilledtimeout` will be verified before this, so ensure to set these timeouts high enough. @@ -176,16 +176,16 @@ class IStrategy(ABC, HyperStrategyMixin): :param trade: trade object. :param order: Order dictionary as returned from CCXT. :param **kwargs: Ensure to keep this here so updates to this won't break your strategy. - :return bool: When True is returned, then the buy-order is cancelled. + :return bool: When True is returned, then the buy/short-order is cancelled. """ return False def check_sell_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool: """ Check sell timeout function callback. - This method can be used to override the sell-timeout. - It is called whenever a limit sell order has been created, - and is not yet fully filled. + This method can be used to override the exit-timeout. + It is called whenever a (long) limit sell order or (short) limit buy + has been created, and is not yet fully filled. Configuration options in `unfilledtimeout` will be verified before this, so ensure to set these timeouts high enough. @@ -194,7 +194,7 @@ class IStrategy(ABC, HyperStrategyMixin): :param trade: trade object. :param order: Order dictionary as returned from CCXT. :param **kwargs: Ensure to keep this here so updates to this won't break your strategy. - :return bool: When True is returned, then the sell-order is cancelled. + :return bool: When True is returned, then the (long)sell/(short)buy-order is cancelled. """ return False @@ -210,7 +210,7 @@ class IStrategy(ABC, HyperStrategyMixin): def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float, time_in_force: str, current_time: datetime, **kwargs) -> bool: """ - Called right before placing a buy order. + Called right before placing a buy/short order. Timing for this function is critical, so avoid doing heavy computations or network requests in this method. @@ -218,7 +218,7 @@ class IStrategy(ABC, HyperStrategyMixin): When not implemented by a strategy, returns True (always confirming). - :param pair: Pair that's about to be bought. + :param pair: Pair that's about to be bought/shorted. :param order_type: Order type (as configured in order_types). usually limit or market. :param amount: Amount in target (quote) currency that's going to be traded. :param rate: Rate that's going to be used when using limit orders @@ -234,7 +234,7 @@ class IStrategy(ABC, HyperStrategyMixin): rate: float, time_in_force: str, sell_reason: str, current_time: datetime, **kwargs) -> bool: """ - Called right before placing a regular sell order. + Called right before placing a regular sell/exit_short order. Timing for this function is critical, so avoid doing heavy computations or network requests in this method. @@ -253,7 +253,7 @@ class IStrategy(ABC, HyperStrategyMixin): 'sell_signal', 'force_sell', 'emergency_sell'] :param current_time: datetime object, containing the current datetime :param **kwargs: Ensure to keep this here so updates to this won't break your strategy. - :return bool: When True is returned, then the sell-order is placed on the exchange. + :return bool: When True, then the sell-order/exit_short-order is placed on the exchange. False aborts the process """ return True @@ -371,7 +371,7 @@ class IStrategy(ABC, HyperStrategyMixin): Checks if a pair is currently locked The 2nd, optional parameter ensures that locks are applied until the new candle arrives, and not stop at 14:00:00 - while the next candle arrives at 14:00:02 leaving a gap - of 2 seconds for a buy to happen on an old signal. + of 2 seconds for a buy/short to happen on an old signal. :param pair: "Pair to check" :param candle_date: Date of the last candle. Optional, defaults to current date :returns: locking state of the pair in question. @@ -387,7 +387,7 @@ class IStrategy(ABC, HyperStrategyMixin): def analyze_ticker(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ Parses the given candle (OHLCV) data and returns a populated DataFrame - add several TA indicators and buy signal to it + add several TA indicators and buy/short signal to it :param dataframe: Dataframe containing data from exchange :param metadata: Metadata dictionary with additional data (e.g. 'pair') :return: DataFrame of candle (OHLCV) data with indicator data and signals added @@ -502,12 +502,14 @@ class IStrategy(ABC, HyperStrategyMixin): dataframe: DataFrame ) -> Tuple[bool, bool, Optional[str]]: """ - Calculates current signal based based on the buy / sell columns of the dataframe. - Used by Bot to get the signal to buy or sell + Calculates current signal based based on the buy/short or sell/exit_short + columns of the dataframe. + Used by Bot to get the signal to buy, sell, short, or exit_short :param pair: pair in format ANT/BTC :param timeframe: timeframe to use :param dataframe: Analyzed dataframe to get signal from. - :return: (Buy, Sell) A bool-tuple indicating buy/sell signal + :return: (Buy, Sell)/(Short, Exit_short) A bool-tuple indicating + (buy/sell)/(short/exit_short) signal """ if not isinstance(dataframe, DataFrame) or dataframe.empty: logger.warning(f'Empty candle (OHLCV) data for pair {pair}') @@ -565,12 +567,12 @@ class IStrategy(ABC, HyperStrategyMixin): sell: bool, low: float = None, high: float = None, force_stoploss: float = 0) -> SellCheckTuple: """ - This function evaluates if one of the conditions required to trigger a sell + This function evaluates if one of the conditions required to trigger a sell/exit_short has been reached, which can either be a stop-loss, ROI or exit-signal. - :param low: Only used during backtesting to simulate stoploss - :param high: Only used during backtesting, to simulate ROI + :param low: Only used during backtesting to simulate (long)stoploss/(short)ROI + :param high: Only used during backtesting, to simulate (short)stoploss/(long)ROI :param force_stoploss: Externally provided stoploss - :return: True if trade should be sold, False otherwise + :return: True if trade should be exited, False otherwise """ current_rate = rate current_profit = trade.calc_profit_ratio(current_rate) @@ -648,7 +650,7 @@ class IStrategy(ABC, HyperStrategyMixin): high: float = None) -> SellCheckTuple: """ Based on current profit of the trade and configured (trailing) stoploss, - decides to sell or not + decides to exit or not :param current_profit: current profit as ratio :param low: Low value of this candle, only set in backtesting :param high: High value of this candle, only set in backtesting @@ -753,7 +755,7 @@ class IStrategy(ABC, HyperStrategyMixin): def advise_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ - Populate indicators that will be used in the Buy and Sell strategy + Populate indicators that will be used in the Buy, Sell, short, exit_short strategy This method should not be overridden. :param dataframe: Dataframe with data from the exchange :param metadata: Additional information, like the currently traded pair @@ -769,7 +771,7 @@ class IStrategy(ABC, HyperStrategyMixin): def advise_buy(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ - Based on TA indicators, populates the buy signal for the given dataframe + Based on TA indicators, populates the buy/short signal for the given dataframe This method should not be overridden. :param dataframe: DataFrame :param metadata: Additional information dictionary, with details like the @@ -788,7 +790,7 @@ class IStrategy(ABC, HyperStrategyMixin): def advise_sell(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ - Based on TA indicators, populates the sell signal for the given dataframe + Based on TA indicators, populates the sell/exit_short signal for the given dataframe This method should not be overridden. :param dataframe: DataFrame :param metadata: Additional information dictionary, with details like the From a5be535cc950d994e94c95448578076791e76ac4 Mon Sep 17 00:00:00 2001 From: Sam Germain Date: Sat, 21 Aug 2021 17:06:04 -0600 Subject: [PATCH 3/3] strategy interface: removed some changes --- freqtrade/optimize/backtesting.py | 5 +---- freqtrade/optimize/hyperopt.py | 6 ++---- freqtrade/strategy/strategy_helper.py | 5 +---- freqtrade/templates/sample_hyperopt.py | 2 +- 4 files changed, 5 insertions(+), 13 deletions(-) diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py index cce3b6a0d..8b3eb46ca 100644 --- a/freqtrade/optimize/backtesting.py +++ b/freqtrade/optimize/backtesting.py @@ -232,10 +232,7 @@ class Backtesting: pair_data.loc[:, 'buy_tag'] = None # cleanup if buy_tag is exist df_analyzed = self.strategy.advise_sell( - self.strategy.advise_buy( - pair_data, - {'pair': pair} - ), + self.strategy.advise_buy(pair_data, {'pair': pair}), {'pair': pair} ).copy() # Trim startup period from analyzed dataframe diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py index 5c627df35..0db78aa39 100644 --- a/freqtrade/optimize/hyperopt.py +++ b/freqtrade/optimize/hyperopt.py @@ -285,13 +285,11 @@ class Hyperopt: # Apply parameters if HyperoptTools.has_space(self.config, 'buy'): self.backtesting.strategy.advise_buy = ( # type: ignore - self.custom_hyperopt.buy_strategy_generator(params_dict) - ) + self.custom_hyperopt.buy_strategy_generator(params_dict)) if HyperoptTools.has_space(self.config, 'sell'): self.backtesting.strategy.advise_sell = ( # type: ignore - self.custom_hyperopt.sell_strategy_generator(params_dict) - ) + self.custom_hyperopt.sell_strategy_generator(params_dict)) if HyperoptTools.has_space(self.config, 'protection'): for attr_name, attr in self.backtesting.strategy.enumerate_parameters('protection'): diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py index 36f284402..121614fbc 100644 --- a/freqtrade/strategy/strategy_helper.py +++ b/freqtrade/strategy/strategy_helper.py @@ -58,10 +58,7 @@ def merge_informative_pair(dataframe: pd.DataFrame, informative: pd.DataFrame, return dataframe -def stoploss_from_open( - open_relative_stop: float, - current_profit: float -) -> float: +def stoploss_from_open(open_relative_stop: float, current_profit: float) -> float: """ Given the current profit, and a desired stop loss value relative to the open price, diff --git a/freqtrade/templates/sample_hyperopt.py b/freqtrade/templates/sample_hyperopt.py index 6e15b436d..7ed726d7a 100644 --- a/freqtrade/templates/sample_hyperopt.py +++ b/freqtrade/templates/sample_hyperopt.py @@ -46,7 +46,7 @@ class SampleHyperOpt(IHyperOpt): """ @staticmethod - def buy_indicator_space() -> List[Dimension]: + def indicator_space() -> List[Dimension]: """ Define your Hyperopt space for searching buy strategy parameters. """