adelorenzo/stable
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

condensed strategy methods down to 2

Browse Source
This commit is contained in:
Sam Germain 2021-08-18 04:19:17 -06:00
parent d4a7d2d444
commit 092780df9d
22 changed files with 451 additions and 773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
freqtrade/edge/edge_positioning.py
View File

@ -167,14 +167,12 @@ class Edge:
pair_data = pair_data.sort_values(by=['date']) pair_data = pair_data.sort_values(by=['date'])
pair_data = pair_data.reset_index(drop=True) pair_data = pair_data.reset_index(drop=True)
df_analyzed = self.strategy.advise_exit( df_analyzed = self.strategy.advise_sell(
dataframe=self.strategy.advise_enter( dataframe=self.strategy.advise_buy(
dataframe=pair_data, dataframe=pair_data,
metadata={'pair': pair}, metadata={'pair': pair}
is_short=False
), ),
metadata={'pair': pair}, metadata={'pair': pair}
is_short=False
)[headers].copy() )[headers].copy()
trades += self._find_trades_for_stoploss_range(df_analyzed, pair, self._stoploss_range) trades += self._find_trades_for_stoploss_range(df_analyzed, pair, self._stoploss_range)

2
freqtrade/enums/signaltype.py
View File

@ -16,4 +16,4 @@ class SignalTagType(Enum):
Enum for signal columns Enum for signal columns
""" """
BUY_TAG = "buy_tag" BUY_TAG = "buy_tag"
SELL_TAG = "sell_tag" SHORT_TAG = "short_tag"

9
freqtrade/optimize/backtesting.py
View File

@ -231,8 +231,13 @@ class Backtesting:
if has_buy_tag: if has_buy_tag:
pair_data.loc[:, 'buy_tag'] = None # cleanup if buy_tag is exist pair_data.loc[:, 'buy_tag'] = None # cleanup if buy_tag is exist
df_analyzed = self.strategy.advise_exit( df_analyzed = self.strategy.advise_sell(
self.strategy.advise_enter(pair_data, {'pair': pair}), {'pair': pair}).copy() self.strategy.advise_buy(
pair_data,
{'pair': pair}
),
{'pair': pair}
).copy()
# Trim startup period from analyzed dataframe # Trim startup period from analyzed dataframe
df_analyzed = trim_dataframe(df_analyzed, self.timerange, df_analyzed = trim_dataframe(df_analyzed, self.timerange,
startup_candles=self.required_startup) startup_candles=self.required_startup)

13
freqtrade/optimize/hyperopt.py
View File

@ -110,7 +110,7 @@ class Hyperopt:
self.backtesting.strategy.advise_indicators = ( # type: ignore self.backtesting.strategy.advise_indicators = ( # type: ignore
self.custom_hyperopt.populate_indicators) # type: ignore self.custom_hyperopt.populate_indicators) # type: ignore
if hasattr(self.custom_hyperopt, 'populate_buy_trend'): if hasattr(self.custom_hyperopt, 'populate_buy_trend'):
self.backtesting.strategy.advise_enter = ( # type: ignore self.backtesting.strategy.advise_buy = ( # type: ignore
self.custom_hyperopt.populate_buy_trend) # type: ignore self.custom_hyperopt.populate_buy_trend) # type: ignore
if hasattr(self.custom_hyperopt, 'populate_sell_trend'): if hasattr(self.custom_hyperopt, 'populate_sell_trend'):
self.backtesting.strategy.advise_sell = ( # type: ignore self.backtesting.strategy.advise_sell = ( # type: ignore
@ -283,14 +283,15 @@ class Hyperopt:
params_dict = self._get_params_dict(self.dimensions, raw_params) params_dict = self._get_params_dict(self.dimensions, raw_params)
# Apply parameters # Apply parameters
# TODO-lev: These don't take a side, how can I pass is_short=True/False to it
if HyperoptTools.has_space(self.config, 'buy'): if HyperoptTools.has_space(self.config, 'buy'):
self.backtesting.strategy.advise_enter = ( # type: ignore 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'): if HyperoptTools.has_space(self.config, 'sell'):
self.backtesting.strategy.advise_exit = ( # type: ignore 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'): if HyperoptTools.has_space(self.config, 'protection'):
for attr_name, attr in self.backtesting.strategy.enumerate_parameters('protection'): for attr_name, attr in self.backtesting.strategy.enumerate_parameters('protection'):

13
freqtrade/resolvers/strategy_resolver.py
View File

@ -202,14 +202,11 @@ class StrategyResolver(IResolver):
strategy._populate_fun_len = len(getfullargspec(strategy.populate_indicators).args) strategy._populate_fun_len = len(getfullargspec(strategy.populate_indicators).args)
strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args) strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args)
strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args) strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args)
strategy._short_fun_len = len(getfullargspec(strategy.populate_short_trend).args) if any(x == 2 for x in [
strategy._exit_short_fun_len = len( strategy._populate_fun_len,
getfullargspec(strategy.populate_exit_short_trend).args) strategy._buy_fun_len,
if any(x == 2 for x in [strategy._populate_fun_len, strategy._sell_fun_len
strategy._buy_fun_len, ]):
strategy._sell_fun_len,
strategy._short_fun_len,
strategy._exit_short_fun_len]):
strategy.INTERFACE_VERSION = 1 strategy.INTERFACE_VERSION = 1
return strategy return strategy

2
freqtrade/rpc/api_server/uvicorn_threaded.py
View File

@ -44,5 +44,5 @@ class UvicornServer(uvicorn.Server):
time.sleep(1e-3) time.sleep(1e-3)
def cleanup(self): def cleanup(self):
self.should_sell = True self.should_exit = True
self.thread.join() self.thread.join()

87
freqtrade/strategy/interface.py
View File

@ -62,8 +62,6 @@ class IStrategy(ABC, HyperStrategyMixin):
_populate_fun_len: int = 0 _populate_fun_len: int = 0
_buy_fun_len: int = 0 _buy_fun_len: int = 0
_sell_fun_len: int = 0 _sell_fun_len: int = 0
_short_fun_len: int = 0
_exit_short_fun_len: int = 0
_ft_params_from_file: Dict = {} _ft_params_from_file: Dict = {}
# associated minimal roi # associated minimal roi
minimal_roi: Dict minimal_roi: Dict
@ -145,7 +143,7 @@ class IStrategy(ABC, HyperStrategyMixin):
return dataframe return dataframe
@abstractmethod @abstractmethod
def populate_enter_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_buy_trend(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 signal for the given dataframe
:param dataframe: DataFrame :param dataframe: DataFrame
@ -155,7 +153,7 @@ class IStrategy(ABC, HyperStrategyMixin):
return dataframe return dataframe
@abstractmethod @abstractmethod
def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_sell_trend(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 signal for the given dataframe
:param dataframe: DataFrame :param dataframe: DataFrame
@ -166,7 +164,7 @@ class IStrategy(ABC, HyperStrategyMixin):
def check_buy_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool: def check_buy_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
""" """
Check enter timeout function callback. Check buy timeout function callback.
This method can be used to override the enter-timeout. This method can be used to override the enter-timeout.
It is called whenever a limit buy/short order has been created, It is called whenever a limit buy/short order has been created,
and is not yet fully filled. and is not yet fully filled.
@ -184,7 +182,7 @@ class IStrategy(ABC, HyperStrategyMixin):
def check_sell_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool: def check_sell_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
""" """
Check exit timeout function callback. Check sell timeout function callback.
This method can be used to override the exit-timeout. This method can be used to override the exit-timeout.
It is called whenever a (long) limit sell order or (short) limit buy It is called whenever a (long) limit sell order or (short) limit buy
has been created, and is not yet fully filled. has been created, and is not yet fully filled.
@ -396,10 +394,8 @@ class IStrategy(ABC, HyperStrategyMixin):
""" """
logger.debug("TA Analysis Launched") logger.debug("TA Analysis Launched")
dataframe = self.advise_indicators(dataframe, metadata) dataframe = self.advise_indicators(dataframe, metadata)
dataframe = self.advise_enter(dataframe, metadata, is_short=False) dataframe = self.advise_buy(dataframe, metadata)
dataframe = self.advise_exit(dataframe, metadata, is_short=False) dataframe = self.advise_sell(dataframe, metadata)
dataframe = self.advise_enter(dataframe, metadata, is_short=True)
dataframe = self.advise_exit(dataframe, metadata, is_short=True)
return dataframe return dataframe
def _analyze_ticker_internal(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def _analyze_ticker_internal(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -426,7 +422,7 @@ class IStrategy(ABC, HyperStrategyMixin):
logger.debug("Skipping TA Analysis for already analyzed candle") logger.debug("Skipping TA Analysis for already analyzed candle")
dataframe['buy'] = 0 dataframe['buy'] = 0
dataframe['sell'] = 0 dataframe['sell'] = 0
dataframe['short'] = 0 dataframe['enter_short'] = 0
dataframe['exit_short'] = 0 dataframe['exit_short'] = 0
dataframe['buy_tag'] = None dataframe['buy_tag'] = None
dataframe['short_tag'] = None dataframe['short_tag'] = None
@ -572,8 +568,8 @@ class IStrategy(ABC, HyperStrategyMixin):
else: else:
return False return False
def should_sell(self, trade: Trade, rate: float, date: datetime, enter: bool, def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool,
exit: bool, low: float = None, high: float = None, sell: bool, low: float = None, high: float = None,
force_stoploss: float = 0) -> SellCheckTuple: force_stoploss: float = 0) -> SellCheckTuple:
""" """
This function evaluates if one of the conditions required to trigger a sell/exit_short This function evaluates if one of the conditions required to trigger a sell/exit_short
@ -597,7 +593,7 @@ class IStrategy(ABC, HyperStrategyMixin):
current_profit = trade.calc_profit_ratio(current_rate) current_profit = trade.calc_profit_ratio(current_rate)
# if enter 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 (enter and self.ignore_roi_if_buy_signal) roi_reached = (not (buy and self.ignore_roi_if_buy_signal)
and self.min_roi_reached(trade=trade, current_profit=current_profit, and self.min_roi_reached(trade=trade, current_profit=current_profit,
current_time=date)) current_time=date))
@ -610,8 +606,8 @@ class IStrategy(ABC, HyperStrategyMixin):
if (self.sell_profit_only and current_profit <= self.sell_profit_offset): if (self.sell_profit_only and current_profit <= self.sell_profit_offset):
# sell_profit_only and profit doesn't reach the offset - ignore sell signal # sell_profit_only and profit doesn't reach the offset - ignore sell signal
pass pass
elif self.use_sell_signal and not enter: elif self.use_sell_signal and not buy:
if exit: if sell:
sell_signal = SellType.SELL_SIGNAL sell_signal = SellType.SELL_SIGNAL
else: else:
trade_type = "exit_short" if trade.is_short else "sell" trade_type = "exit_short" if trade.is_short else "sell"
@ -759,7 +755,7 @@ class IStrategy(ABC, HyperStrategyMixin):
def ohlcvdata_to_dataframe(self, data: Dict[str, DataFrame]) -> Dict[str, DataFrame]: def ohlcvdata_to_dataframe(self, data: Dict[str, DataFrame]) -> Dict[str, DataFrame]:
""" """
Populates indicators for given candle (OHLCV) data (for multiple pairs) Populates indicators for given candle (OHLCV) data (for multiple pairs)
Does not run advise_enter or advise_exit! Does not run advise_buy or advise_sell!
Used by optimize operations only, not during dry / live runs. Used by optimize operations only, not during dry / live runs.
Using .copy() to get a fresh copy of the dataframe for every strategy run. Using .copy() to get a fresh copy of the dataframe for every strategy run.
Has positive effects on memory usage for whatever reason - also when Has positive effects on memory usage for whatever reason - also when
@ -784,12 +780,7 @@ class IStrategy(ABC, HyperStrategyMixin):
else: else:
return self.populate_indicators(dataframe, metadata) return self.populate_indicators(dataframe, metadata)
def advise_enter( def advise_buy(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
self,
dataframe: DataFrame,
metadata: dict,
is_short: bool = False
) -> DataFrame:
""" """
Based on TA indicators, populates the buy/short signal for the given dataframe Based on TA indicators, populates the buy/short signal for the given dataframe
This method should not be overridden. This method should not be overridden.
@ -798,27 +789,17 @@ class IStrategy(ABC, HyperStrategyMixin):
currently traded pair currently traded pair
:return: DataFrame with buy column :return: DataFrame with buy column
""" """
(type, fun_len) = (
("short", self._short_fun_len)
if is_short else
("buy", self._buy_fun_len)
)
logger.debug(f"Populating {type} signals for pair {metadata.get('pair')}.") logger.debug(f"Populating enter signals for pair {metadata.get('pair')}.")
if fun_len == 2: if self._buy_fun_len == 2:
warnings.warn("deprecated - check out the Sample strategy to see " warnings.warn("deprecated - check out the Sample strategy to see "
"the current function headers!", DeprecationWarning) "the current function headers!", DeprecationWarning)
return self.populate_enter_trend(dataframe) # type: ignore return self.populate_buy_trend(dataframe) # type: ignore
else: else:
return self.populate_enter_trend(dataframe, metadata) return self.populate_buy_trend(dataframe, metadata)
def advise_exit( def advise_sell(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
self,
dataframe: DataFrame,
metadata: dict,
is_short: bool = False
) -> DataFrame:
""" """
Based on TA indicators, populates the sell/exit_short 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. This method should not be overridden.
@ -828,16 +809,26 @@ class IStrategy(ABC, HyperStrategyMixin):
:return: DataFrame with sell column :return: DataFrame with sell column
""" """
(type, fun_len) = ( logger.debug(f"Populating exit signals for pair {metadata.get('pair')}.")
("exit_short", self._exit_short_fun_len) if self._sell_fun_len == 2:
if is_short else
("sell", self._sell_fun_len)
)
logger.debug(f"Populating {type} signals for pair {metadata.get('pair')}.")
if fun_len == 2:
warnings.warn("deprecated - check out the Sample strategy to see " warnings.warn("deprecated - check out the Sample strategy to see "
"the current function headers!", DeprecationWarning) "the current function headers!", DeprecationWarning)
return self.populate_exit_trend(dataframe) # type: ignore return self.populate_sell_trend(dataframe) # type: ignore
else: else:
return self.populate_exit_trend(dataframe, metadata) return self.populate_sell_trend(dataframe, metadata)
def leverage(self, pair: str, current_time: datetime, current_rate: float,
proposed_leverage: float, max_leverage: float,
**kwargs) -> float:
"""
Customize leverage for each new trade. This method is not called when edge module is
enabled.
:param pair: Pair that's currently analyzed
:param current_time: datetime object, containing the current datetime
:param current_rate: Rate, calculated based on pricing settings in ask_strategy.
:param proposed_leverage: A leverage proposed by the bot.
:param max_leverage: Max leverage allowed on this pair
:return: A stake size, which is between min_stake and max_stake.
"""
return proposed_leverage

9
freqtrade/strategy/strategy_helper.py
View File

@ -1,5 +1,6 @@
import pandas as pd import pandas as pd
from freqtrade.exceptions import OperationalException
from freqtrade.exchange import timeframe_to_minutes from freqtrade.exchange import timeframe_to_minutes
@ -83,7 +84,13 @@ def stoploss_from_open(
if current_profit == -1: if current_profit == -1:
return 1 return 1
stoploss = 1-((1+open_relative_stop)/(1+current_profit)) # TODO-lev: Is this right? if for_short is True:
# TODO-lev: How would this be calculated for short
raise OperationalException(
"Freqtrade hasn't figured out how to calculated stoploss on shorts")
# stoploss = 1-((1+open_relative_stop)/(1+current_profit))
else:
stoploss = 1-((1+open_relative_stop)/(1+current_profit))
# negative stoploss values indicate the requested stop price is higher than the current price # negative stoploss values indicate the requested stop price is higher than the current price
if for_short: if for_short:

237
freqtrade/templates/sample_hyperopt.py
View File

@ -46,7 +46,7 @@ class SampleHyperOpt(IHyperOpt):
""" """
@staticmethod @staticmethod
def indicator_space() -> List[Dimension]: def buy_indicator_space() -> List[Dimension]:
""" """
Define your Hyperopt space for searching buy strategy parameters. Define your Hyperopt space for searching buy strategy parameters.
""" """
@ -55,11 +55,16 @@ class SampleHyperOpt(IHyperOpt):
Integer(15, 45, name='fastd-value'), Integer(15, 45, name='fastd-value'),
Integer(20, 50, name='adx-value'), Integer(20, 50, name='adx-value'),
Integer(20, 40, name='rsi-value'), Integer(20, 40, name='rsi-value'),
Integer(75, 90, name='short-mfi-value'),
Integer(55, 85, name='short-fastd-value'),
Integer(50, 80, name='short-adx-value'),
Integer(60, 80, name='short-rsi-value'),
Categorical([True, False], name='mfi-enabled'), Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'), Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'), Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-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 @staticmethod
@ -71,39 +76,61 @@ class SampleHyperOpt(IHyperOpt):
""" """
Buy strategy Hyperopt will build and use. Buy strategy Hyperopt will build and use.
""" """
conditions = [] long_conditions = []
short_conditions = []
# GUARDS AND TRENDS # GUARDS AND TRENDS
if 'mfi-enabled' in params and params['mfi-enabled']: if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] < params['mfi-value']) long_conditions.append(dataframe['mfi'] < params['mfi-value'])
short_conditions.append(dataframe['mfi'] > params['short-mfi-value'])
if 'fastd-enabled' in params and params['fastd-enabled']: if 'fastd-enabled' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] < params['fastd-value']) long_conditions.append(dataframe['fastd'] < params['fastd-value'])
short_conditions.append(dataframe['fastd'] > params['short-fastd-value'])
if 'adx-enabled' in params and params['adx-enabled']: if 'adx-enabled' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] > params['adx-value']) long_conditions.append(dataframe['adx'] > params['adx-value'])
short_conditions.append(dataframe['adx'] < params['short-adx-value'])
if 'rsi-enabled' in params and params['rsi-enabled']: if 'rsi-enabled' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] < params['rsi-value']) long_conditions.append(dataframe['rsi'] < params['rsi-value'])
short_conditions.append(dataframe['rsi'] > params['short-rsi-value'])
# TRIGGERS # TRIGGERS
if 'trigger' in params: if 'trigger' in params:
if params['trigger'] == 'bb_lower': if params['trigger'] == 'boll':
conditions.append(dataframe['close'] < dataframe['bb_lowerband']) long_conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
short_conditions.append(dataframe['close'] > dataframe['bb_upperband'])
if params['trigger'] == 'macd_cross_signal': if params['trigger'] == 'macd_cross_signal':
conditions.append(qtpylib.crossed_above( long_conditions.append(qtpylib.crossed_above(
dataframe['macd'], dataframe['macdsignal'] dataframe['macd'],
dataframe['macdsignal']
))
short_conditions.append(qtpylib.crossed_below(
dataframe['macd'],
dataframe['macdsignal']
)) ))
if params['trigger'] == 'sar_reversal': if params['trigger'] == 'sar_reversal':
conditions.append(qtpylib.crossed_above( long_conditions.append(qtpylib.crossed_above(
dataframe['close'], dataframe['sar'] dataframe['close'],
dataframe['sar']
))
short_conditions.append(qtpylib.crossed_below(
dataframe['close'],
dataframe['sar']
)) ))
# Check that volume is not 0 # Check that volume is not 0
conditions.append(dataframe['volume'] > 0) long_conditions.append(dataframe['volume'] > 0)
short_conditions.append(dataframe['volume'] > 0)
if conditions: if long_conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, long_conditions),
'buy'] = 1 'buy'] = 1
if short_conditions:
dataframe.loc[
reduce(lambda x, y: x & y, short_conditions),
'enter_short'] = 1
return dataframe return dataframe
return populate_buy_trend return populate_buy_trend
@ -118,13 +145,19 @@ class SampleHyperOpt(IHyperOpt):
Integer(50, 100, name='sell-fastd-value'), Integer(50, 100, name='sell-fastd-value'),
Integer(50, 100, name='sell-adx-value'), Integer(50, 100, name='sell-adx-value'),
Integer(60, 100, name='sell-rsi-value'), Integer(60, 100, name='sell-rsi-value'),
Integer(1, 25, name='exit-short-mfi-value'),
Integer(1, 50, name='exit-short-fastd-value'),
Integer(1, 50, name='exit-short-adx-value'),
Integer(1, 40, name='exit-short-rsi-value'),
Categorical([True, False], name='sell-mfi-enabled'), Categorical([True, False], name='sell-mfi-enabled'),
Categorical([True, False], name='sell-fastd-enabled'), Categorical([True, False], name='sell-fastd-enabled'),
Categorical([True, False], name='sell-adx-enabled'), Categorical([True, False], name='sell-adx-enabled'),
Categorical([True, False], name='sell-rsi-enabled'), Categorical([True, False], name='sell-rsi-enabled'),
Categorical(['sell-bb_upper', Categorical(['sell-boll',
'sell-macd_cross_signal', 'sell-macd_cross_signal',
'sell-sar_reversal'], name='sell-trigger') 'sell-sar_reversal'],
name='sell-trigger'
),
] ]
@staticmethod @staticmethod
@ -136,161 +169,61 @@ class SampleHyperOpt(IHyperOpt):
""" """
Sell strategy Hyperopt will build and use. Sell strategy Hyperopt will build and use.
""" """
conditions = [] exit_long_conditions = []
exit_short_conditions = []
# GUARDS AND TRENDS # GUARDS AND TRENDS
if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']: 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'])
exit_short_conditions.append(dataframe['mfi'] < params['exit-short-mfi-value'])
if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']: 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'])
exit_short_conditions.append(dataframe['fastd'] < params['exit-short-fastd-value'])
if 'sell-adx-enabled' in params and params['sell-adx-enabled']: 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'])
exit_short_conditions.append(dataframe['adx'] > params['exit-short-adx-value'])
if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']: 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'])
exit_short_conditions.append(dataframe['rsi'] < params['exit-short-rsi-value'])
# TRIGGERS # TRIGGERS
if 'sell-trigger' in params: 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']) exit_long_conditions.append(dataframe['close'] > dataframe['bb_upperband'])
exit_short_conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
if params['sell-trigger'] == 'sell-macd_cross_signal': if params['sell-trigger'] == 'sell-macd_cross_signal':
conditions.append(qtpylib.crossed_above( exit_long_conditions.append(qtpylib.crossed_above(
dataframe['macdsignal'], dataframe['macd'] dataframe['macdsignal'],
dataframe['macd']
))
exit_short_conditions.append(qtpylib.crossed_below(
dataframe['macdsignal'],
dataframe['macd']
)) ))
if params['sell-trigger'] == 'sell-sar_reversal': if params['sell-trigger'] == 'sell-sar_reversal':
conditions.append(qtpylib.crossed_above( exit_long_conditions.append(qtpylib.crossed_above(
dataframe['sar'], dataframe['close'] dataframe['sar'],
dataframe['close']
))
exit_short_conditions.append(qtpylib.crossed_below(
dataframe['sar'],
dataframe['close']
)) ))
# Check that volume is not 0 # Check that volume is not 0
conditions.append(dataframe['volume'] > 0) exit_long_conditions.append(dataframe['volume'] > 0)
exit_short_conditions.append(dataframe['volume'] > 0)
if conditions: if exit_long_conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, exit_long_conditions),
'sell'] = 1 'sell'] = 1
return dataframe if exit_short_conditions:
return populate_sell_trend
@staticmethod
def short_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the short strategy parameters to be used by Hyperopt.
"""
def populate_short_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Buy strategy Hyperopt will build and use.
"""
conditions = []
# GUARDS AND TRENDS
if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] > params['mfi-value'])
if 'fastd-enabled' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] > params['fastd-value'])
if 'adx-enabled' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] < params['adx-value'])
if 'rsi-enabled' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] > params['rsi-value'])
# TRIGGERS
if 'trigger' in params:
if params['trigger'] == 'bb_upper':
conditions.append(dataframe['close'] > dataframe['bb_upperband'])
if params['trigger'] == 'macd_cross_signal':
conditions.append(qtpylib.crossed_below(
dataframe['macd'], dataframe['macdsignal']
))
if params['trigger'] == 'sar_reversal':
conditions.append(qtpylib.crossed_below(
dataframe['close'], dataframe['sar']
))
if conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, exit_short_conditions),
'short'] = 1
return dataframe
return populate_short_trend
@staticmethod
def short_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching short strategy parameters.
"""
return [
Integer(75, 90, name='mfi-value'),
Integer(55, 85, name='fastd-value'),
Integer(50, 80, name='adx-value'),
Integer(60, 80, name='rsi-value'),
Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-enabled'),
Categorical(['bb_upper', 'macd_cross_signal', 'sar_reversal'], name='trigger')
]
@staticmethod
def exit_short_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the exit_short strategy parameters to be used by Hyperopt.
"""
def populate_exit_short_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Exit_short strategy Hyperopt will build and use.
"""
conditions = []
# GUARDS AND TRENDS
if 'exit-short-mfi-enabled' in params and params['exit-short-mfi-enabled']:
conditions.append(dataframe['mfi'] < params['exit-short-mfi-value'])
if 'exit-short-fastd-enabled' in params and params['exit-short-fastd-enabled']:
conditions.append(dataframe['fastd'] < params['exit-short-fastd-value'])
if 'exit-short-adx-enabled' in params and params['exit-short-adx-enabled']:
conditions.append(dataframe['adx'] > params['exit-short-adx-value'])
if 'exit-short-rsi-enabled' in params and params['exit-short-rsi-enabled']:
conditions.append(dataframe['rsi'] < params['exit-short-rsi-value'])
# TRIGGERS
if 'exit-short-trigger' in params:
if params['exit-short-trigger'] == 'exit-short-bb_lower':
conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
if params['exit-short-trigger'] == 'exit-short-macd_cross_signal':
conditions.append(qtpylib.crossed_below(
dataframe['macdsignal'], dataframe['macd']
))
if params['exit-short-trigger'] == 'exit-short-sar_reversal':
conditions.append(qtpylib.crossed_below(
dataframe['sar'], dataframe['close']
))
if conditions:
dataframe.loc[
reduce(lambda x, y: x & y, conditions),
'exit_short'] = 1 'exit_short'] = 1
return dataframe return dataframe
return populate_exit_short_trend return populate_sell_trend
@staticmethod
def exit_short_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching exit short strategy parameters.
"""
return [
Integer(1, 25, name='exit_short-mfi-value'),
Integer(1, 50, name='exit_short-fastd-value'),
Integer(1, 50, name='exit_short-adx-value'),
Integer(1, 40, name='exit_short-rsi-value'),
Categorical([True, False], name='exit_short-mfi-enabled'),
Categorical([True, False], name='exit_short-fastd-enabled'),
Categorical([True, False], name='exit_short-adx-enabled'),
Categorical([True, False], name='exit_short-rsi-enabled'),
Categorical(['exit_short-bb_lower',
'exit_short-macd_cross_signal',
'exit_short-sar_reversal'], name='exit_short-trigger')
]

233
freqtrade/templates/sample_hyperopt_advanced.py
View File

@ -70,11 +70,15 @@ class AdvancedSampleHyperOpt(IHyperOpt):
Integer(15, 45, name='fastd-value'), Integer(15, 45, name='fastd-value'),
Integer(20, 50, name='adx-value'), Integer(20, 50, name='adx-value'),
Integer(20, 40, name='rsi-value'), Integer(20, 40, name='rsi-value'),
Integer(75, 90, name='short-mfi-value'),
Integer(55, 85, name='short-fastd-value'),
Integer(50, 80, name='short-adx-value'),
Integer(60, 80, name='short-rsi-value'),
Categorical([True, False], name='mfi-enabled'), Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'), Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'), Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-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 @staticmethod
@ -86,38 +90,60 @@ class AdvancedSampleHyperOpt(IHyperOpt):
""" """
Buy strategy Hyperopt will build and use Buy strategy Hyperopt will build and use
""" """
conditions = [] long_conditions = []
short_conditions = []
# GUARDS AND TRENDS # GUARDS AND TRENDS
if 'mfi-enabled' in params and params['mfi-enabled']: if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] < params['mfi-value']) long_conditions.append(dataframe['mfi'] < params['mfi-value'])
short_conditions.append(dataframe['mfi'] > params['short-mfi-value'])
if 'fastd-enabled' in params and params['fastd-enabled']: if 'fastd-enabled' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] < params['fastd-value']) long_conditions.append(dataframe['fastd'] < params['fastd-value'])
short_conditions.append(dataframe['fastd'] > params['short-fastd-value'])
if 'adx-enabled' in params and params['adx-enabled']: if 'adx-enabled' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] > params['adx-value']) long_conditions.append(dataframe['adx'] > params['adx-value'])
short_conditions.append(dataframe['adx'] < params['short-adx-value'])
if 'rsi-enabled' in params and params['rsi-enabled']: if 'rsi-enabled' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] < params['rsi-value']) long_conditions.append(dataframe['rsi'] < params['rsi-value'])
short_conditions.append(dataframe['rsi'] > params['short-rsi-value'])
# TRIGGERS # TRIGGERS
if 'trigger' in params: if 'trigger' in params:
if params['trigger'] == 'bb_lower': if params['trigger'] == 'boll':
conditions.append(dataframe['close'] < dataframe['bb_lowerband']) long_conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
short_conditions.append(dataframe['close'] > dataframe['bb_upperband'])
if params['trigger'] == 'macd_cross_signal': if params['trigger'] == 'macd_cross_signal':
conditions.append(qtpylib.crossed_above( long_conditions.append(qtpylib.crossed_above(
dataframe['macd'], dataframe['macdsignal'] dataframe['macd'],
dataframe['macdsignal']
))
short_conditions.append(qtpylib.crossed_below(
dataframe['macd'],
dataframe['macdsignal']
)) ))
if params['trigger'] == 'sar_reversal': if params['trigger'] == 'sar_reversal':
conditions.append(qtpylib.crossed_above( long_conditions.append(qtpylib.crossed_above(
dataframe['close'], dataframe['sar'] dataframe['close'],
dataframe['sar']
))
short_conditions.append(qtpylib.crossed_below(
dataframe['close'],
dataframe['sar']
)) ))
# Check that volume is not 0 # Check that volume is not 0
conditions.append(dataframe['volume'] > 0) long_conditions.append(dataframe['volume'] > 0)
short_conditions.append(dataframe['volume'] > 0)
if conditions: if long_conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, long_conditions),
'buy'] = 1 'buy'] = 1
if short_conditions:
dataframe.loc[
reduce(lambda x, y: x & y, short_conditions),
'enter_short'] = 1
return dataframe return dataframe
return populate_buy_trend return populate_buy_trend
@ -132,13 +158,18 @@ class AdvancedSampleHyperOpt(IHyperOpt):
Integer(50, 100, name='sell-fastd-value'), Integer(50, 100, name='sell-fastd-value'),
Integer(50, 100, name='sell-adx-value'), Integer(50, 100, name='sell-adx-value'),
Integer(60, 100, name='sell-rsi-value'), Integer(60, 100, name='sell-rsi-value'),
Integer(1, 25, name='exit_short-mfi-value'),
Integer(1, 50, name='exit_short-fastd-value'),
Integer(1, 50, name='exit_short-adx-value'),
Integer(1, 40, name='exit_short-rsi-value'),
Categorical([True, False], name='sell-mfi-enabled'), Categorical([True, False], name='sell-mfi-enabled'),
Categorical([True, False], name='sell-fastd-enabled'), Categorical([True, False], name='sell-fastd-enabled'),
Categorical([True, False], name='sell-adx-enabled'), Categorical([True, False], name='sell-adx-enabled'),
Categorical([True, False], name='sell-rsi-enabled'), Categorical([True, False], name='sell-rsi-enabled'),
Categorical(['sell-bb_upper', Categorical(['sell-boll',
'sell-macd_cross_signal', 'sell-macd_cross_signal',
'sell-sar_reversal'], name='sell-trigger') 'sell-sar_reversal'],
name='sell-trigger')
] ]
@staticmethod @staticmethod
@ -151,163 +182,63 @@ class AdvancedSampleHyperOpt(IHyperOpt):
Sell strategy Hyperopt will build and use Sell strategy Hyperopt will build and use
""" """
# print(params) # print(params)
conditions = [] exit_long_conditions = []
exit_short_conditions = []
# GUARDS AND TRENDS # GUARDS AND TRENDS
if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']: 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'])
exit_short_conditions.append(dataframe['mfi'] < params['exit-short-mfi-value'])
if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']: 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'])
exit_short_conditions.append(dataframe['fastd'] < params['exit-short-fastd-value'])
if 'sell-adx-enabled' in params and params['sell-adx-enabled']: 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'])
exit_short_conditions.append(dataframe['adx'] > params['exit-short-adx-value'])
if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']: 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'])
exit_short_conditions.append(dataframe['rsi'] < params['exit-short-rsi-value'])
# TRIGGERS # TRIGGERS
if 'sell-trigger' in params: 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']) exit_long_conditions.append(dataframe['close'] > dataframe['bb_upperband'])
exit_short_conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
if params['sell-trigger'] == 'sell-macd_cross_signal': if params['sell-trigger'] == 'sell-macd_cross_signal':
conditions.append(qtpylib.crossed_above( exit_long_conditions.append(qtpylib.crossed_above(
dataframe['macdsignal'], dataframe['macd'] dataframe['macdsignal'],
dataframe['macd']
))
exit_long_conditions.append(qtpylib.crossed_below(
dataframe['macdsignal'],
dataframe['macd']
)) ))
if params['sell-trigger'] == 'sell-sar_reversal': if params['sell-trigger'] == 'sell-sar_reversal':
conditions.append(qtpylib.crossed_above( exit_long_conditions.append(qtpylib.crossed_above(
dataframe['sar'], dataframe['close'] dataframe['sar'],
dataframe['close']
))
exit_long_conditions.append(qtpylib.crossed_below(
dataframe['sar'],
dataframe['close']
)) ))
# Check that volume is not 0 # Check that volume is not 0
conditions.append(dataframe['volume'] > 0) exit_long_conditions.append(dataframe['volume'] > 0)
exit_short_conditions.append(dataframe['volume'] > 0)
if conditions: if exit_long_conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, exit_long_conditions),
'sell'] = 1 'sell'] = 1
return dataframe if exit_short_conditions:
return populate_sell_trend
@staticmethod
def short_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the short strategy parameters to be used by Hyperopt.
"""
def populate_short_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Buy strategy Hyperopt will build and use.
"""
conditions = []
# GUARDS AND TRENDS
if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] > params['mfi-value'])
if 'fastd-enabled' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] > params['fastd-value'])
if 'adx-enabled' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] < params['adx-value'])
if 'rsi-enabled' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] > params['rsi-value'])
# TRIGGERS
if 'trigger' in params:
if params['trigger'] == 'bb_upper':
conditions.append(dataframe['close'] > dataframe['bb_upperband'])
if params['trigger'] == 'macd_cross_signal':
conditions.append(qtpylib.crossed_below(
dataframe['macd'], dataframe['macdsignal']
))
if params['trigger'] == 'sar_reversal':
conditions.append(qtpylib.crossed_below(
dataframe['close'], dataframe['sar']
))
if conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, exit_short_conditions),
'short'] = 1
return dataframe
return populate_short_trend
@staticmethod
def short_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching short strategy parameters.
"""
return [
Integer(75, 90, name='mfi-value'),
Integer(55, 85, name='fastd-value'),
Integer(50, 80, name='adx-value'),
Integer(60, 80, name='rsi-value'),
Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-enabled'),
Categorical(['bb_upper', 'macd_cross_signal', 'sar_reversal'], name='trigger')
]
@staticmethod
def exit_short_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the exit_short strategy parameters to be used by Hyperopt.
"""
def populate_exit_short_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Exit_short strategy Hyperopt will build and use.
"""
conditions = []
# GUARDS AND TRENDS
if 'exit-short-mfi-enabled' in params and params['exit-short-mfi-enabled']:
conditions.append(dataframe['mfi'] < params['exit-short-mfi-value'])
if 'exit-short-fastd-enabled' in params and params['exit-short-fastd-enabled']:
conditions.append(dataframe['fastd'] < params['exit-short-fastd-value'])
if 'exit-short-adx-enabled' in params and params['exit-short-adx-enabled']:
conditions.append(dataframe['adx'] > params['exit-short-adx-value'])
if 'exit-short-rsi-enabled' in params and params['exit-short-rsi-enabled']:
conditions.append(dataframe['rsi'] < params['exit-short-rsi-value'])
# TRIGGERS
if 'exit-short-trigger' in params:
if params['exit-short-trigger'] == 'exit-short-bb_lower':
conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
if params['exit-short-trigger'] == 'exit-short-macd_cross_signal':
conditions.append(qtpylib.crossed_below(
dataframe['macdsignal'], dataframe['macd']
))
if params['exit-short-trigger'] == 'exit-short-sar_reversal':
conditions.append(qtpylib.crossed_below(
dataframe['sar'], dataframe['close']
))
if conditions:
dataframe.loc[
reduce(lambda x, y: x & y, conditions),
'exit_short'] = 1 'exit_short'] = 1
return dataframe return dataframe
return populate_exit_short_trend return populate_sell_trend
@staticmethod
def exit_short_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching exit short strategy parameters.
"""
return [
Integer(1, 25, name='exit_short-mfi-value'),
Integer(1, 50, name='exit_short-fastd-value'),
Integer(1, 50, name='exit_short-adx-value'),
Integer(1, 40, name='exit_short-rsi-value'),
Categorical([True, False], name='exit_short-mfi-enabled'),
Categorical([True, False], name='exit_short-fastd-enabled'),
Categorical([True, False], name='exit_short-adx-enabled'),
Categorical([True, False], name='exit_short-rsi-enabled'),
Categorical(['exit_short-bb_lower',
'exit_short-macd_cross_signal',
'exit_short-sar_reversal'], name='exit_short-trigger')
]
@staticmethod @staticmethod
def generate_roi_table(params: Dict) -> Dict[int, float]: def generate_roi_table(params: Dict) -> Dict[int, float]:

41
freqtrade/templates/sample_strategy.py
View File

@ -29,7 +29,7 @@ class SampleStrategy(IStrategy):
You must keep: You must keep:
- the lib in the section "Do not remove these libs" - the lib in the section "Do not remove these libs"
- the methods: populate_indicators, populate_buy_trend, populate_sell_trend, populate_short_trend, populate_exit_short_trend - the methods: populate_indicators, populate_buy_trend, populate_sell_trend
You should keep: You should keep:
- timeframe, minimal_roi, stoploss, trailing_* - timeframe, minimal_roi, stoploss, trailing_*
""" """
@ -356,6 +356,16 @@ class SampleStrategy(IStrategy):
), ),
'buy'] = 1 'buy'] = 1
dataframe.loc[
(
# Signal: RSI crosses above 70
(qtpylib.crossed_above(dataframe['rsi'], self.short_rsi.value)) &
(dataframe['tema'] > dataframe['bb_middleband']) & # Guard: tema above BB middle
(dataframe['tema'] < dataframe['tema'].shift(1)) & # Guard: tema is falling
(dataframe['volume'] > 0) # Make sure Volume is not 0
),
'enter_short'] = 1
return dataframe return dataframe
def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -374,38 +384,13 @@ class SampleStrategy(IStrategy):
(dataframe['volume'] > 0) # Make sure Volume is not 0 (dataframe['volume'] > 0) # Make sure Volume is not 0
), ),
'sell'] = 1 'sell'] = 1
return dataframe
def populate_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the short signal for the given dataframe
:param dataframe: DataFrame populated with indicators
:param metadata: Additional information, like the currently traded pair
:return: DataFrame with short column
"""
dataframe.loc[
(
# Signal: RSI crosses above 70
(qtpylib.crossed_above(dataframe['rsi'], self.short_rsi.value)) &
(dataframe['tema'] > dataframe['bb_middleband']) & # Guard: tema above BB middle
(dataframe['tema'] < dataframe['tema'].shift(1)) & # Guard: tema is falling
(dataframe['volume'] > 0) # Make sure Volume is not 0
),
'short'] = 1
return dataframe
def populate_exit_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the exit_short signal for the given dataframe
:param dataframe: DataFrame populated with indicators
:param metadata: Additional information, like the currently traded pair
:return: DataFrame with exit_short column
"""
dataframe.loc[ dataframe.loc[
( (
# Signal: RSI crosses above 30 # Signal: RSI crosses above 30
(qtpylib.crossed_above(dataframe['rsi'], self.exit_short_rsi.value)) & (qtpylib.crossed_above(dataframe['rsi'], self.exit_short_rsi.value)) &
(dataframe['tema'] <= dataframe['bb_middleband']) & # Guard: tema below BB middle # Guard: tema below BB middle
(dataframe['tema'] <= dataframe['bb_middleband']) &
(dataframe['tema'] > dataframe['tema'].shift(1)) & # Guard: tema is raising (dataframe['tema'] > dataframe['tema'].shift(1)) & # Guard: tema is raising
(dataframe['volume'] > 0) # Make sure Volume is not 0 (dataframe['volume'] > 0) # Make sure Volume is not 0
), ),

267
tests/optimize/hyperopts/default_hyperopt.py
View File

@ -54,36 +54,57 @@ class DefaultHyperOpt(IHyperOpt):
""" """
Buy strategy Hyperopt will build and use. Buy strategy Hyperopt will build and use.
""" """
conditions = [] long_conditions = []
short_conditions = []
# GUARDS AND TRENDS # GUARDS AND TRENDS
if 'mfi-enabled' in params and params['mfi-enabled']: if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] < params['mfi-value']) long_conditions.append(dataframe['mfi'] < params['mfi-value'])
short_conditions.append(dataframe['mfi'] > params['short-mfi-value'])
if 'fastd-enabled' in params and params['fastd-enabled']: if 'fastd-enabled' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] < params['fastd-value']) long_conditions.append(dataframe['fastd'] < params['fastd-value'])
short_conditions.append(dataframe['fastd'] > params['short-fastd-value'])
if 'adx-enabled' in params and params['adx-enabled']: if 'adx-enabled' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] > params['adx-value']) long_conditions.append(dataframe['adx'] > params['adx-value'])
short_conditions.append(dataframe['adx'] < params['short-adx-value'])
if 'rsi-enabled' in params and params['rsi-enabled']: if 'rsi-enabled' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] < params['rsi-value']) long_conditions.append(dataframe['rsi'] < params['rsi-value'])
short_conditions.append(dataframe['rsi'] > params['short-rsi-value'])
# TRIGGERS # TRIGGERS
if 'trigger' in params: if 'trigger' in params:
if params['trigger'] == 'bb_lower': if params['trigger'] == 'boll':
conditions.append(dataframe['close'] < dataframe['bb_lowerband']) long_conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
short_conditions.append(dataframe['close'] > dataframe['bb_upperband'])
if params['trigger'] == 'macd_cross_signal': if params['trigger'] == 'macd_cross_signal':
conditions.append(qtpylib.crossed_above( long_conditions.append(qtpylib.crossed_above(
dataframe['macd'], dataframe['macdsignal'] dataframe['macd'],
dataframe['macdsignal']
))
short_conditions.append(qtpylib.crossed_below(
dataframe['macd'],
dataframe['macdsignal']
)) ))
if params['trigger'] == 'sar_reversal': if params['trigger'] == 'sar_reversal':
conditions.append(qtpylib.crossed_above( long_conditions.append(qtpylib.crossed_above(
dataframe['close'], dataframe['sar'] dataframe['close'],
dataframe['sar']
))
short_conditions.append(qtpylib.crossed_below(
dataframe['close'],
dataframe['sar']
)) ))
if conditions: if long_conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, long_conditions),
'buy'] = 1 'buy'] = 1
if short_conditions:
dataframe.loc[
reduce(lambda x, y: x & y, short_conditions),
'enter_short'] = 1
return dataframe return dataframe
return populate_buy_trend return populate_buy_trend
@ -98,71 +119,15 @@ class DefaultHyperOpt(IHyperOpt):
Integer(15, 45, name='fastd-value'), Integer(15, 45, name='fastd-value'),
Integer(20, 50, name='adx-value'), Integer(20, 50, name='adx-value'),
Integer(20, 40, name='rsi-value'), Integer(20, 40, name='rsi-value'),
Integer(75, 90, name='short-mfi-value'),
Integer(55, 85, name='short-fastd-value'),
Integer(50, 80, name='short-adx-value'),
Integer(60, 80, name='short-rsi-value'),
Categorical([True, False], name='mfi-enabled'), Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'), Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'), Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-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
def short_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the short strategy parameters to be used by Hyperopt.
"""
def populate_short_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Buy strategy Hyperopt will build and use.
"""
conditions = []
# GUARDS AND TRENDS
if 'mfi-enabled' in params and params['mfi-enabled']:
conditions.append(dataframe['mfi'] > params['mfi-value'])
if 'fastd-enabled' in params and params['fastd-enabled']:
conditions.append(dataframe['fastd'] > params['fastd-value'])
if 'adx-enabled' in params and params['adx-enabled']:
conditions.append(dataframe['adx'] < params['adx-value'])
if 'rsi-enabled' in params and params['rsi-enabled']:
conditions.append(dataframe['rsi'] > params['rsi-value'])
# TRIGGERS
if 'trigger' in params:
if params['trigger'] == 'bb_upper':
conditions.append(dataframe['close'] > dataframe['bb_upperband'])
if params['trigger'] == 'macd_cross_signal':
conditions.append(qtpylib.crossed_below(
dataframe['macd'], dataframe['macdsignal']
))
if params['trigger'] == 'sar_reversal':
conditions.append(qtpylib.crossed_below(
dataframe['close'], dataframe['sar']
))
if conditions:
dataframe.loc[
reduce(lambda x, y: x & y, conditions),
'short'] = 1
return dataframe
return populate_short_trend
@staticmethod
def short_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching short strategy parameters.
"""
return [
Integer(75, 90, name='mfi-value'),
Integer(55, 85, name='fastd-value'),
Integer(50, 80, name='adx-value'),
Integer(60, 80, name='rsi-value'),
Categorical([True, False], name='mfi-enabled'),
Categorical([True, False], name='fastd-enabled'),
Categorical([True, False], name='adx-enabled'),
Categorical([True, False], name='rsi-enabled'),
Categorical(['bb_upper', 'macd_cross_signal', 'sar_reversal'], name='trigger')
] ]
@staticmethod @staticmethod
@ -174,83 +139,61 @@ class DefaultHyperOpt(IHyperOpt):
""" """
Sell strategy Hyperopt will build and use. Sell strategy Hyperopt will build and use.
""" """
conditions = [] exit_long_conditions = []
exit_short_conditions = []
# GUARDS AND TRENDS # GUARDS AND TRENDS
if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']: 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'])
exit_short_conditions.append(dataframe['mfi'] < params['exit-short-mfi-value'])
if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']: 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'])
exit_short_conditions.append(dataframe['fastd'] < params['exit-short-fastd-value'])
if 'sell-adx-enabled' in params and params['sell-adx-enabled']: 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'])
exit_short_conditions.append(dataframe['adx'] > params['exit-short-adx-value'])
if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']: 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'])
exit_short_conditions.append(dataframe['rsi'] < params['exit-short-rsi-value'])
# TRIGGERS # TRIGGERS
if 'sell-trigger' in params: 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']) exit_long_conditions.append(dataframe['close'] > dataframe['bb_upperband'])
exit_short_conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
if params['sell-trigger'] == 'sell-macd_cross_signal': if params['sell-trigger'] == 'sell-macd_cross_signal':
conditions.append(qtpylib.crossed_above( exit_long_conditions.append(qtpylib.crossed_above(
dataframe['macdsignal'], dataframe['macd'] dataframe['macdsignal'],
dataframe['macd']
))
exit_short_conditions.append(qtpylib.crossed_below(
dataframe['macdsignal'],
dataframe['macd']
)) ))
if params['sell-trigger'] == 'sell-sar_reversal': if params['sell-trigger'] == 'sell-sar_reversal':
conditions.append(qtpylib.crossed_above( exit_long_conditions.append(qtpylib.crossed_above(
dataframe['sar'], dataframe['close'] dataframe['sar'],
dataframe['close']
))
exit_short_conditions.append(qtpylib.crossed_below(
dataframe['sar'],
dataframe['close']
)) ))
if conditions: if exit_long_conditions:
dataframe.loc[ dataframe.loc[
reduce(lambda x, y: x & y, conditions), reduce(lambda x, y: x & y, exit_long_conditions),
'sell'] = 1 'sell'] = 1
if exit_short_conditions:
dataframe.loc[
reduce(lambda x, y: x & y, exit_short_conditions),
'exit-short'] = 1
return dataframe return dataframe
return populate_sell_trend return populate_sell_trend
@staticmethod
def exit_short_strategy_generator(params: Dict[str, Any]) -> Callable:
"""
Define the exit_short strategy parameters to be used by Hyperopt.
"""
def populate_exit_short_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Exit_short strategy Hyperopt will build and use.
"""
conditions = []
# GUARDS AND TRENDS
if 'exit-short-mfi-enabled' in params and params['exit-short-mfi-enabled']:
conditions.append(dataframe['mfi'] < params['exit-short-mfi-value'])
if 'exit-short-fastd-enabled' in params and params['exit-short-fastd-enabled']:
conditions.append(dataframe['fastd'] < params['exit-short-fastd-value'])
if 'exit-short-adx-enabled' in params and params['exit-short-adx-enabled']:
conditions.append(dataframe['adx'] > params['exit-short-adx-value'])
if 'exit-short-rsi-enabled' in params and params['exit-short-rsi-enabled']:
conditions.append(dataframe['rsi'] < params['exit-short-rsi-value'])
# TRIGGERS
if 'exit-short-trigger' in params:
if params['exit-short-trigger'] == 'exit-short-bb_lower':
conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
if params['exit-short-trigger'] == 'exit-short-macd_cross_signal':
conditions.append(qtpylib.crossed_below(
dataframe['macdsignal'], dataframe['macd']
))
if params['exit-short-trigger'] == 'exit-short-sar_reversal':
conditions.append(qtpylib.crossed_below(
dataframe['sar'], dataframe['close']
))
if conditions:
dataframe.loc[
reduce(lambda x, y: x & y, conditions),
'exit_short'] = 1
return dataframe
return populate_exit_short_trend
@staticmethod @staticmethod
def sell_indicator_space() -> List[Dimension]: def sell_indicator_space() -> List[Dimension]:
""" """
@ -261,32 +204,18 @@ class DefaultHyperOpt(IHyperOpt):
Integer(50, 100, name='sell-fastd-value'), Integer(50, 100, name='sell-fastd-value'),
Integer(50, 100, name='sell-adx-value'), Integer(50, 100, name='sell-adx-value'),
Integer(60, 100, name='sell-rsi-value'), Integer(60, 100, name='sell-rsi-value'),
Integer(1, 25, name='exit-short-mfi-value'),
Integer(1, 50, name='exit-short-fastd-value'),
Integer(1, 50, name='exit-short-adx-value'),
Integer(1, 40, name='exit-short-rsi-value'),
Categorical([True, False], name='sell-mfi-enabled'), Categorical([True, False], name='sell-mfi-enabled'),
Categorical([True, False], name='sell-fastd-enabled'), Categorical([True, False], name='sell-fastd-enabled'),
Categorical([True, False], name='sell-adx-enabled'), Categorical([True, False], name='sell-adx-enabled'),
Categorical([True, False], name='sell-rsi-enabled'), Categorical([True, False], name='sell-rsi-enabled'),
Categorical(['sell-bb_upper', Categorical(['sell-boll',
'sell-macd_cross_signal', 'sell-macd_cross_signal',
'sell-sar_reversal'], name='sell-trigger') 'sell-sar_reversal'],
] name='sell-trigger')
@staticmethod
def exit_short_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching exit short strategy parameters.
"""
return [
Integer(1, 25, name='exit_short-mfi-value'),
Integer(1, 50, name='exit_short-fastd-value'),
Integer(1, 50, name='exit_short-adx-value'),
Integer(1, 40, name='exit_short-rsi-value'),
Categorical([True, False], name='exit_short-mfi-enabled'),
Categorical([True, False], name='exit_short-fastd-enabled'),
Categorical([True, False], name='exit_short-adx-enabled'),
Categorical([True, False], name='exit_short-rsi-enabled'),
Categorical(['exit_short-bb_lower',
'exit_short-macd_cross_signal',
'exit_short-sar_reversal'], name='exit_short-trigger')
] ]
def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -304,6 +233,15 @@ class DefaultHyperOpt(IHyperOpt):
), ),
'buy'] = 1 'buy'] = 1
dataframe.loc[
(
(dataframe['close'] > dataframe['bb_upperband']) &
(dataframe['mfi'] < 84) &
(dataframe['adx'] > 75) &
(dataframe['rsi'] < 79)
),
'enter_short'] = 1
return dataframe return dataframe
def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -321,31 +259,6 @@ class DefaultHyperOpt(IHyperOpt):
), ),
'sell'] = 1 'sell'] = 1
return dataframe
def populate_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators. Should be a copy of same method from strategy.
Must align to populate_indicators in this file.
Only used when --spaces does not include short space.
"""
dataframe.loc[
(
(dataframe['close'] > dataframe['bb_upperband']) &
(dataframe['mfi'] < 84) &
(dataframe['adx'] > 75) &
(dataframe['rsi'] < 79)
),
'buy'] = 1
return dataframe
def populate_exit_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators. Should be a copy of same method from strategy.
Must align to populate_indicators in this file.
Only used when --spaces does not include exit_short space.
"""
dataframe.loc[ dataframe.loc[
( (
(qtpylib.crossed_below( (qtpylib.crossed_below(
@ -353,6 +266,6 @@ class DefaultHyperOpt(IHyperOpt):
)) & )) &
(dataframe['fastd'] < 46) (dataframe['fastd'] < 46)
), ),
'sell'] = 1 'exit_short'] = 1
return dataframe return dataframe

4
tests/optimize/test_backtest_detail.py
View File

@ -597,8 +597,8 @@ def test_backtest_results(default_conf, fee, mocker, caplog, data) -> None:
backtesting = Backtesting(default_conf) backtesting = Backtesting(default_conf)
backtesting._set_strategy(backtesting.strategylist[0]) backtesting._set_strategy(backtesting.strategylist[0])
backtesting.required_startup = 0 backtesting.required_startup = 0
backtesting.strategy.advise_enter = lambda a, m: frame backtesting.strategy.advise_buy = lambda a, m: frame
backtesting.strategy.advise_exit = lambda a, m: frame backtesting.strategy.advise_sell = lambda a, m: frame
backtesting.strategy.use_custom_stoploss = data.use_custom_stoploss backtesting.strategy.use_custom_stoploss = data.use_custom_stoploss
caplog.set_level(logging.DEBUG) caplog.set_level(logging.DEBUG)

20
tests/optimize/test_backtesting.py
View File

@ -290,8 +290,8 @@ def test_backtesting_init(mocker, default_conf, order_types) -> None:
assert backtesting.config == default_conf assert backtesting.config == default_conf
assert backtesting.timeframe == '5m' assert backtesting.timeframe == '5m'
assert callable(backtesting.strategy.ohlcvdata_to_dataframe) assert callable(backtesting.strategy.ohlcvdata_to_dataframe)
assert callable(backtesting.strategy.advise_enter) assert callable(backtesting.strategy.advise_buy)
assert callable(backtesting.strategy.advise_exit) assert callable(backtesting.strategy.advise_sell)
assert isinstance(backtesting.strategy.dp, DataProvider) assert isinstance(backtesting.strategy.dp, DataProvider)
get_fee.assert_called() get_fee.assert_called()
assert backtesting.fee == 0.5 assert backtesting.fee == 0.5
@ -700,8 +700,8 @@ def test_backtest_clash_buy_sell(mocker, default_conf, testdatadir):
backtest_conf = _make_backtest_conf(mocker, conf=default_conf, datadir=testdatadir) backtest_conf = _make_backtest_conf(mocker, conf=default_conf, datadir=testdatadir)
backtesting = Backtesting(default_conf) backtesting = Backtesting(default_conf)
backtesting._set_strategy(backtesting.strategylist[0]) backtesting._set_strategy(backtesting.strategylist[0])
backtesting.strategy.advise_enter = fun # Override backtesting.strategy.advise_buy = fun # Override
backtesting.strategy.advise_exit = fun # Override backtesting.strategy.advise_sell = fun # Override
result = backtesting.backtest(**backtest_conf) result = backtesting.backtest(**backtest_conf)
assert result['results'].empty assert result['results'].empty
@ -716,8 +716,8 @@ def test_backtest_only_sell(mocker, default_conf, testdatadir):
backtest_conf = _make_backtest_conf(mocker, conf=default_conf, datadir=testdatadir) backtest_conf = _make_backtest_conf(mocker, conf=default_conf, datadir=testdatadir)
backtesting = Backtesting(default_conf) backtesting = Backtesting(default_conf)
backtesting._set_strategy(backtesting.strategylist[0]) backtesting._set_strategy(backtesting.strategylist[0])
backtesting.strategy.advise_enter = fun # Override backtesting.strategy.advise_buy = fun # Override
backtesting.strategy.advise_exit = fun # Override backtesting.strategy.advise_sell = fun # Override
result = backtesting.backtest(**backtest_conf) result = backtesting.backtest(**backtest_conf)
assert result['results'].empty assert result['results'].empty
@ -731,8 +731,8 @@ def test_backtest_alternate_buy_sell(default_conf, fee, mocker, testdatadir):
backtesting = Backtesting(default_conf) backtesting = Backtesting(default_conf)
backtesting.required_startup = 0 backtesting.required_startup = 0
backtesting._set_strategy(backtesting.strategylist[0]) backtesting._set_strategy(backtesting.strategylist[0])
backtesting.strategy.advise_enter = _trend_alternate # Override backtesting.strategy.advise_buy = _trend_alternate # Override
backtesting.strategy.advise_exit = _trend_alternate # Override backtesting.strategy.advise_sell = _trend_alternate # Override
result = backtesting.backtest(**backtest_conf) result = backtesting.backtest(**backtest_conf)
# 200 candles in backtest data # 200 candles in backtest data
# won't buy on first (shifted by 1) # won't buy on first (shifted by 1)
@ -777,8 +777,8 @@ def test_backtest_multi_pair(default_conf, fee, mocker, tres, pair, testdatadir)
backtesting = Backtesting(default_conf) backtesting = Backtesting(default_conf)
backtesting._set_strategy(backtesting.strategylist[0]) backtesting._set_strategy(backtesting.strategylist[0])
backtesting.strategy.advise_enter = _trend_alternate_hold # Override backtesting.strategy.advise_buy = _trend_alternate_hold # Override
backtesting.strategy.advise_exit = _trend_alternate_hold # Override backtesting.strategy.advise_sell = _trend_alternate_hold # Override
processed = backtesting.strategy.ohlcvdata_to_dataframe(data) processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
min_date, max_date = get_timerange(processed) min_date, max_date = get_timerange(processed)

40
tests/optimize/test_hyperopt.py
View File

@ -366,8 +366,8 @@ def test_start_calls_optimizer(mocker, hyperopt_conf, capsys) -> None:
# Should be called for historical candle data # Should be called for historical candle data
assert dumper.call_count == 1 assert dumper.call_count == 1
assert dumper2.call_count == 1 assert dumper2.call_count == 1
assert hasattr(hyperopt.backtesting.strategy, "advise_exit") assert hasattr(hyperopt.backtesting.strategy, "advise_sell")
assert hasattr(hyperopt.backtesting.strategy, "advise_enter") assert hasattr(hyperopt.backtesting.strategy, "advise_buy")
assert hasattr(hyperopt, "max_open_trades") assert hasattr(hyperopt, "max_open_trades")
assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades'] assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades']
assert hasattr(hyperopt, "position_stacking") assert hasattr(hyperopt, "position_stacking")
@ -451,6 +451,10 @@ def test_buy_strategy_generator(hyperopt, testdatadir) -> None:
'fastd-value': 20, 'fastd-value': 20,
'mfi-value': 20, 'mfi-value': 20,
'rsi-value': 20, 'rsi-value': 20,
'short-adx-value': 80,
'short-fastd-value': 80,
'short-mfi-value': 80,
'short-rsi-value': 80,
'adx-enabled': True, 'adx-enabled': True,
'fastd-enabled': True, 'fastd-enabled': True,
'mfi-enabled': True, 'mfi-enabled': True,
@ -476,6 +480,10 @@ def test_sell_strategy_generator(hyperopt, testdatadir) -> None:
'sell-fastd-value': 75, 'sell-fastd-value': 75,
'sell-mfi-value': 80, 'sell-mfi-value': 80,
'sell-rsi-value': 20, 'sell-rsi-value': 20,
'exit-short-adx-value': 80,
'exit-short-fastd-value': 25,
'exit-short-mfi-value': 20,
'exit-short-rsi-value': 80,
'sell-adx-enabled': True, 'sell-adx-enabled': True,
'sell-fastd-enabled': True, 'sell-fastd-enabled': True,
'sell-mfi-enabled': True, 'sell-mfi-enabled': True,
@ -534,6 +542,10 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
'fastd-value': 35, 'fastd-value': 35,
'mfi-value': 0, 'mfi-value': 0,
'rsi-value': 0, 'rsi-value': 0,
'short-adx-value': 100,
'short-fastd-value': 65,
'short-mfi-value': 100,
'short-rsi-value': 100,
'adx-enabled': False, 'adx-enabled': False,
'fastd-enabled': True, 'fastd-enabled': True,
'mfi-enabled': False, 'mfi-enabled': False,
@ -543,6 +555,10 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
'sell-fastd-value': 75, 'sell-fastd-value': 75,
'sell-mfi-value': 0, 'sell-mfi-value': 0,
'sell-rsi-value': 0, 'sell-rsi-value': 0,
'exit-short-adx-value': 100,
'exit-short-fastd-value': 25,
'exit-short-mfi-value': 100,
'exit-short-rsi-value': 100,
'sell-adx-enabled': False, 'sell-adx-enabled': False,
'sell-fastd-enabled': True, 'sell-fastd-enabled': True,
'sell-mfi-enabled': False, 'sell-mfi-enabled': False,
@ -569,12 +585,16 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
), ),
'params_details': {'buy': {'adx-enabled': False, 'params_details': {'buy': {'adx-enabled': False,
'adx-value': 0, 'adx-value': 0,
'short-adx-value': 100,
'fastd-enabled': True, 'fastd-enabled': True,
'fastd-value': 35, 'fastd-value': 35,
'short-fastd-value': 65,
'mfi-enabled': False, 'mfi-enabled': False,
'mfi-value': 0, 'mfi-value': 0,
'short-mfi-value': 100,
'rsi-enabled': False, 'rsi-enabled': False,
'rsi-value': 0, 'rsi-value': 0,
'short-rsi-value': 100,
'trigger': 'macd_cross_signal'}, 'trigger': 'macd_cross_signal'},
'roi': {"0": 0.12000000000000001, 'roi': {"0": 0.12000000000000001,
"20.0": 0.02, "20.0": 0.02,
@ -583,12 +603,16 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
'protection': {}, 'protection': {},
'sell': {'sell-adx-enabled': False, 'sell': {'sell-adx-enabled': False,
'sell-adx-value': 0, 'sell-adx-value': 0,
'exit-short-adx-value': 100,
'sell-fastd-enabled': True, 'sell-fastd-enabled': True,
'sell-fastd-value': 75, 'sell-fastd-value': 75,
'exit-short-fastd-value': 25,
'sell-mfi-enabled': False, 'sell-mfi-enabled': False,
'sell-mfi-value': 0, 'sell-mfi-value': 0,
'exit-short-mfi-value': 100,
'sell-rsi-enabled': False, 'sell-rsi-enabled': False,
'sell-rsi-value': 0, 'sell-rsi-value': 0,
'exit-short-rsi-value': 100,
'sell-trigger': 'macd_cross_signal'}, 'sell-trigger': 'macd_cross_signal'},
'stoploss': {'stoploss': -0.4}, 'stoploss': {'stoploss': -0.4},
'trailing': {'trailing_only_offset_is_reached': False, 'trailing': {'trailing_only_offset_is_reached': False,
@ -825,8 +849,8 @@ def test_simplified_interface_roi_stoploss(mocker, hyperopt_conf, capsys) -> Non
assert dumper.call_count == 1 assert dumper.call_count == 1
assert dumper2.call_count == 1 assert dumper2.call_count == 1
assert hasattr(hyperopt.backtesting.strategy, "advise_exit") assert hasattr(hyperopt.backtesting.strategy, "advise_sell")
assert hasattr(hyperopt.backtesting.strategy, "advise_enter") assert hasattr(hyperopt.backtesting.strategy, "advise_buy")
assert hasattr(hyperopt, "max_open_trades") assert hasattr(hyperopt, "max_open_trades")
assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades'] assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades']
assert hasattr(hyperopt, "position_stacking") assert hasattr(hyperopt, "position_stacking")
@ -906,8 +930,8 @@ def test_simplified_interface_buy(mocker, hyperopt_conf, capsys) -> None:
assert dumper.called assert dumper.called
assert dumper.call_count == 1 assert dumper.call_count == 1
assert dumper2.call_count == 1 assert dumper2.call_count == 1
assert hasattr(hyperopt.backtesting.strategy, "advise_exit") assert hasattr(hyperopt.backtesting.strategy, "advise_sell")
assert hasattr(hyperopt.backtesting.strategy, "advise_enter") assert hasattr(hyperopt.backtesting.strategy, "advise_buy")
assert hasattr(hyperopt, "max_open_trades") assert hasattr(hyperopt, "max_open_trades")
assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades'] assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades']
assert hasattr(hyperopt, "position_stacking") assert hasattr(hyperopt, "position_stacking")
@ -960,8 +984,8 @@ def test_simplified_interface_sell(mocker, hyperopt_conf, capsys) -> None:
assert dumper.called assert dumper.called
assert dumper.call_count == 1 assert dumper.call_count == 1
assert dumper2.call_count == 1 assert dumper2.call_count == 1
assert hasattr(hyperopt.backtesting.strategy, "advise_exit") assert hasattr(hyperopt.backtesting.strategy, "advise_sell")
assert hasattr(hyperopt.backtesting.strategy, "advise_enter") assert hasattr(hyperopt.backtesting.strategy, "advise_buy")
assert hasattr(hyperopt, "max_open_trades") assert hasattr(hyperopt, "max_open_trades")
assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades'] assert hyperopt.max_open_trades == hyperopt_conf['max_open_trades']
assert hasattr(hyperopt, "position_stacking") assert hasattr(hyperopt, "position_stacking")

2
tests/rpc/test_rpc_apiserver.py
View File

@ -264,7 +264,7 @@ def test_api_UvicornServer(mocker):
assert thread_mock.call_count == 1 assert thread_mock.call_count == 1
s.cleanup() s.cleanup()
assert s.should_sell is True assert s.should_exit is True
def test_api_UvicornServer_run(mocker): def test_api_UvicornServer_run(mocker):

44
tests/strategy/strats/default_strategy.py
View File

@ -130,6 +130,19 @@ class DefaultStrategy(IStrategy):
), ),
'buy'] = 1 'buy'] = 1
dataframe.loc[
(
(dataframe['rsi'] > 65) &
(dataframe['fastd'] > 65) &
(dataframe['adx'] < 70) &
(dataframe['plus_di'] < 0.5) # TODO-lev: What to do here
) |
(
(dataframe['adx'] < 35) &
(dataframe['plus_di'] < 0.5) # TODO-lev: What to do here
),
'enter_short'] = 1
return dataframe return dataframe
def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -153,37 +166,7 @@ class DefaultStrategy(IStrategy):
(dataframe['minus_di'] > 0.5) (dataframe['minus_di'] > 0.5)
), ),
'sell'] = 1 'sell'] = 1
return dataframe
def populate_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the short signal for the given dataframe
:param dataframe: DataFrame
:param metadata: Additional information, like the currently traded pair
:return: DataFrame with short column
"""
dataframe.loc[
(
(dataframe['rsi'] > 65) &
(dataframe['fastd'] > 65) &
(dataframe['adx'] < 70) &
(dataframe['plus_di'] < 0.5) # TODO-lev: What to do here
) |
(
(dataframe['adx'] < 35) &
(dataframe['plus_di'] < 0.5) # TODO-lev: What to do here
),
'short'] = 1
return dataframe
def populate_exit_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the exit_short signal for the given dataframe
:param dataframe: DataFrame
:param metadata: Additional information, like the currently traded pair
:return: DataFrame with exit_short column
"""
dataframe.loc[ dataframe.loc[
( (
( (
@ -198,4 +181,5 @@ class DefaultStrategy(IStrategy):
(dataframe['minus_di'] < 0.5) # TODO-lev: what to do here (dataframe['minus_di'] < 0.5) # TODO-lev: what to do here
), ),
'exit_short'] = 1 'exit_short'] = 1
return dataframe return dataframe

50
tests/strategy/strats/hyperoptable_strategy.py
View File

@ -60,7 +60,7 @@ class HyperoptableStrategy(IStrategy):
'sell_minusdi': 0.4 'sell_minusdi': 0.4
} }
short_params = { enter_short_params = {
'short_rsi': 65, 'short_rsi': 65,
} }
@ -87,8 +87,8 @@ class HyperoptableStrategy(IStrategy):
}) })
return prot return prot
short_rsi = IntParameter([50, 100], default=70, space='sell') enter_short_rsi = IntParameter([50, 100], default=70, space='sell')
short_plusdi = RealParameter(low=0, high=1, default=0.5, space='sell') enter_short_plusdi = RealParameter(low=0, high=1, default=0.5, space='sell')
exit_short_rsi = IntParameter(low=0, high=50, default=30, space='buy') exit_short_rsi = IntParameter(low=0, high=50, default=30, space='buy')
exit_short_minusdi = DecimalParameter(low=0, high=1, default=0.4999, decimals=3, space='buy', exit_short_minusdi = DecimalParameter(low=0, high=1, default=0.4999, decimals=3, space='buy',
load=False) load=False)
@ -175,6 +175,19 @@ class HyperoptableStrategy(IStrategy):
), ),
'buy'] = 1 'buy'] = 1
dataframe.loc[
(
(dataframe['rsi'] > self.enter_short_rsi.value) &
(dataframe['fastd'] > 65) &
(dataframe['adx'] < 70) &
(dataframe['plus_di'] < self.enter_short_plusdi.value)
) |
(
(dataframe['adx'] < 35) &
(dataframe['plus_di'] < self.enter_short_plusdi.value)
),
'enter_short'] = 1
return dataframe return dataframe
def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -198,37 +211,7 @@ class HyperoptableStrategy(IStrategy):
(dataframe['minus_di'] > self.sell_minusdi.value) (dataframe['minus_di'] > self.sell_minusdi.value)
), ),
'sell'] = 1 'sell'] = 1
return dataframe
def populate_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the short signal for the given dataframe
:param dataframe: DataFrame
:param metadata: Additional information, like the currently traded pair
:return: DataFrame with short column
"""
dataframe.loc[
(
(dataframe['rsi'] > self.short_rsi.value) &
(dataframe['fastd'] > 65) &
(dataframe['adx'] < 70) &
(dataframe['plus_di'] < self.short_plusdi.value)
) |
(
(dataframe['adx'] < 35) &
(dataframe['plus_di'] < self.short_plusdi.value)
),
'short'] = 1
return dataframe
def populate_exit_short_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the exit_short signal for the given dataframe
:param dataframe: DataFrame
:param metadata: Additional information, like the currently traded pair
:return: DataFrame with exit_short column
"""
dataframe.loc[ dataframe.loc[
( (
( (
@ -243,4 +226,5 @@ class HyperoptableStrategy(IStrategy):
(dataframe['minus_di'] < self.exit_short_minusdi.value) (dataframe['minus_di'] < self.exit_short_minusdi.value)
), ),
'exit_short'] = 1 'exit_short'] = 1
return dataframe return dataframe

30
tests/strategy/strats/legacy_strategy.py
View File

@ -84,35 +84,5 @@ class TestStrategyLegacy(IStrategy):
(dataframe['volume'] > 0) (dataframe['volume'] > 0)
), ),
'sell'] = 1 'sell'] = 1
return dataframe
def populate_short_trend(self, dataframe: DataFrame) -> DataFrame:
"""
Based on TA indicators, populates the buy signal for the given dataframe
:param dataframe: DataFrame
:return: DataFrame with buy column
"""
dataframe.loc[
(
(dataframe['adx'] > 30) &
(dataframe['tema'] > dataframe['tema'].shift(1)) &
(dataframe['volume'] > 0)
),
'buy'] = 1
return dataframe return dataframe
def populate_exit_short_trend(self, dataframe: DataFrame) -> DataFrame:
"""
Based on TA indicators, populates the sell signal for the given dataframe
:param dataframe: DataFrame
:return: DataFrame with buy column
"""
dataframe.loc[
(
(dataframe['adx'] > 70) &
(dataframe['tema'] < dataframe['tema'].shift(1)) &
(dataframe['volume'] > 0)
),
'sell'] = 1
return dataframe

27
tests/strategy/test_default_strategy.py
View File

@ -14,8 +14,6 @@ def test_default_strategy_structure():
assert hasattr(DefaultStrategy, 'populate_indicators') assert hasattr(DefaultStrategy, 'populate_indicators')
assert hasattr(DefaultStrategy, 'populate_buy_trend') assert hasattr(DefaultStrategy, 'populate_buy_trend')
assert hasattr(DefaultStrategy, 'populate_sell_trend') assert hasattr(DefaultStrategy, 'populate_sell_trend')
assert hasattr(DefaultStrategy, 'populate_short_trend')
assert hasattr(DefaultStrategy, 'populate_exit_short_trend')
def test_default_strategy(result, fee): def test_default_strategy(result, fee):
@ -29,10 +27,6 @@ def test_default_strategy(result, fee):
assert type(indicators) is DataFrame assert type(indicators) is DataFrame
assert type(strategy.populate_buy_trend(indicators, metadata)) is DataFrame assert type(strategy.populate_buy_trend(indicators, metadata)) is DataFrame
assert type(strategy.populate_sell_trend(indicators, metadata)) is DataFrame assert type(strategy.populate_sell_trend(indicators, metadata)) is DataFrame
# TODO-lev: I think these two should be commented out in the strategy by default
# TODO-lev: so they can be tested, but the tests can't really remain
assert type(strategy.populate_short_trend(indicators, metadata)) is DataFrame
assert type(strategy.populate_exit_short_trend(indicators, metadata)) is DataFrame
trade = Trade( trade = Trade(
open_rate=19_000, open_rate=19_000,
@ -43,28 +37,11 @@ def test_default_strategy(result, fee):
assert strategy.confirm_trade_entry(pair='ETH/BTC', order_type='limit', amount=0.1, assert strategy.confirm_trade_entry(pair='ETH/BTC', order_type='limit', amount=0.1,
rate=20000, time_in_force='gtc', rate=20000, time_in_force='gtc',
is_short=False, current_time=datetime.utcnow()) is True current_time=datetime.utcnow()) is True
assert strategy.confirm_trade_exit(pair='ETH/BTC', trade=trade, order_type='limit', amount=0.1, assert strategy.confirm_trade_exit(pair='ETH/BTC', trade=trade, order_type='limit', amount=0.1,
rate=20000, time_in_force='gtc', sell_reason='roi', rate=20000, time_in_force='gtc', sell_reason='roi',
is_short=False, current_time=datetime.utcnow()) is True current_time=datetime.utcnow()) is True
# TODO-lev: Test for shorts? # TODO-lev: Test for shorts?
assert strategy.custom_stoploss(pair='ETH/BTC', trade=trade, current_time=datetime.now(), assert strategy.custom_stoploss(pair='ETH/BTC', trade=trade, current_time=datetime.now(),
current_rate=20_000, current_profit=0.05) == strategy.stoploss current_rate=20_000, current_profit=0.05) == strategy.stoploss
short_trade = Trade(
open_rate=21_000,
amount=0.1,
pair='ETH/BTC',
fee_open=fee.return_value
)
assert strategy.confirm_trade_entry(pair='ETH/BTC', order_type='limit', amount=0.1,
rate=20000, time_in_force='gtc',
is_short=True, current_time=datetime.utcnow()) is True
assert strategy.confirm_trade_exit(pair='ETH/BTC', trade=short_trade, order_type='limit',
amount=0.1, rate=20000, time_in_force='gtc',
sell_reason='roi', is_short=True,
current_time=datetime.utcnow()) is True

32
tests/strategy/test_interface.py
View File

@ -482,20 +482,20 @@ def test_custom_sell(default_conf, fee, caplog) -> None:
def test_analyze_ticker_default(ohlcv_history, mocker, caplog) -> None: def test_analyze_ticker_default(ohlcv_history, mocker, caplog) -> None:
caplog.set_level(logging.DEBUG) caplog.set_level(logging.DEBUG)
ind_mock = MagicMock(side_effect=lambda x, meta: x) ind_mock = MagicMock(side_effect=lambda x, meta: x)
enter_mock = MagicMock(side_effect=lambda x, meta, is_short: x) buy_mock = MagicMock(side_effect=lambda x, meta: x)
exit_mock = MagicMock(side_effect=lambda x, meta, is_short: x) sell_mock = MagicMock(side_effect=lambda x, meta: x)
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.strategy.interface.IStrategy', 'freqtrade.strategy.interface.IStrategy',
advise_indicators=ind_mock, advise_indicators=ind_mock,
advise_enter=enter_mock, advise_buy=buy_mock,
advise_exit=exit_mock, advise_sell=sell_mock,
) )
strategy = DefaultStrategy({}) strategy = DefaultStrategy({})
strategy.analyze_ticker(ohlcv_history, {'pair': 'ETH/BTC'}) strategy.analyze_ticker(ohlcv_history, {'pair': 'ETH/BTC'})
assert ind_mock.call_count == 1 assert ind_mock.call_count == 1
assert enter_mock.call_count == 2 assert buy_mock.call_count == 1
assert enter_mock.call_count == 2 assert buy_mock.call_count == 1
assert log_has('TA Analysis Launched', caplog) assert log_has('TA Analysis Launched', caplog)
assert not log_has('Skipping TA Analysis for already analyzed candle', caplog) assert not log_has('Skipping TA Analysis for already analyzed candle', caplog)
@ -504,8 +504,8 @@ def test_analyze_ticker_default(ohlcv_history, mocker, caplog) -> None:
strategy.analyze_ticker(ohlcv_history, {'pair': 'ETH/BTC'}) strategy.analyze_ticker(ohlcv_history, {'pair': 'ETH/BTC'})
# No analysis happens as process_only_new_candles is true # No analysis happens as process_only_new_candles is true
assert ind_mock.call_count == 2 assert ind_mock.call_count == 2
assert enter_mock.call_count == 4 assert buy_mock.call_count == 2
assert enter_mock.call_count == 4 assert buy_mock.call_count == 2
assert log_has('TA Analysis Launched', caplog) assert log_has('TA Analysis Launched', caplog)
assert not log_has('Skipping TA Analysis for already analyzed candle', caplog) assert not log_has('Skipping TA Analysis for already analyzed candle', caplog)
@ -513,13 +513,13 @@ def test_analyze_ticker_default(ohlcv_history, mocker, caplog) -> None:
def test__analyze_ticker_internal_skip_analyze(ohlcv_history, mocker, caplog) -> None: def test__analyze_ticker_internal_skip_analyze(ohlcv_history, mocker, caplog) -> None:
caplog.set_level(logging.DEBUG) caplog.set_level(logging.DEBUG)
ind_mock = MagicMock(side_effect=lambda x, meta: x) ind_mock = MagicMock(side_effect=lambda x, meta: x)
enter_mock = MagicMock(side_effect=lambda x, meta, is_short: x) buy_mock = MagicMock(side_effect=lambda x, meta: x)
exit_mock = MagicMock(side_effect=lambda x, meta, is_short: x) sell_mock = MagicMock(side_effect=lambda x, meta: x)
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.strategy.interface.IStrategy', 'freqtrade.strategy.interface.IStrategy',
advise_indicators=ind_mock, advise_indicators=ind_mock,
advise_enter=enter_mock, advise_buy=buy_mock,
advise_exit=exit_mock, advise_sell=sell_mock,
) )
strategy = DefaultStrategy({}) strategy = DefaultStrategy({})
@ -532,8 +532,8 @@ def test__analyze_ticker_internal_skip_analyze(ohlcv_history, mocker, caplog) ->
assert 'close' in ret.columns assert 'close' in ret.columns
assert isinstance(ret, DataFrame) assert isinstance(ret, DataFrame)
assert ind_mock.call_count == 1 assert ind_mock.call_count == 1
assert enter_mock.call_count == 2 # Once for buy, once for short assert buy_mock.call_count == 1
assert enter_mock.call_count == 2 assert buy_mock.call_count == 1
assert log_has('TA Analysis Launched', caplog) assert log_has('TA Analysis Launched', caplog)
assert not log_has('Skipping TA Analysis for already analyzed candle', caplog) assert not log_has('Skipping TA Analysis for already analyzed candle', caplog)
caplog.clear() caplog.clear()
@ -541,8 +541,8 @@ def test__analyze_ticker_internal_skip_analyze(ohlcv_history, mocker, caplog) ->
ret = strategy._analyze_ticker_internal(ohlcv_history, {'pair': 'ETH/BTC'}) ret = strategy._analyze_ticker_internal(ohlcv_history, {'pair': 'ETH/BTC'})
# No analysis happens as process_only_new_candles is true # No analysis happens as process_only_new_candles is true
assert ind_mock.call_count == 1 assert ind_mock.call_count == 1
assert enter_mock.call_count == 2 assert buy_mock.call_count == 1
assert enter_mock.call_count == 2 assert buy_mock.call_count == 1
# only skipped analyze adds buy and sell columns, otherwise it's all mocked # only skipped analyze adds buy and sell columns, otherwise it's all mocked
assert 'buy' in ret.columns assert 'buy' in ret.columns
assert 'sell' in ret.columns assert 'sell' in ret.columns

52
tests/strategy/test_strategy_loading.py
View File

@ -117,16 +117,12 @@ def test_strategy(result, default_conf):
df_indicators = strategy.advise_indicators(result, metadata=metadata) df_indicators = strategy.advise_indicators(result, metadata=metadata)
assert 'adx' in df_indicators assert 'adx' in df_indicators
dataframe = strategy.advise_enter(df_indicators, metadata=metadata, is_short=False) dataframe = strategy.advise_buy(df_indicators, metadata=metadata)
assert 'buy' in dataframe.columns assert 'buy' in dataframe.columns
assert 'enter_short' in dataframe.columns
dataframe = strategy.advise_exit(df_indicators, metadata=metadata, is_short=False) dataframe = strategy.advise_sell(df_indicators, metadata=metadata)
assert 'sell' in dataframe.columns assert 'sell' in dataframe.columns
dataframe = strategy.advise_enter(df_indicators, metadata=metadata, is_short=True)
assert 'short' in dataframe.columns
dataframe = strategy.advise_exit(df_indicators, metadata=metadata, is_short=True)
assert 'exit_short' in dataframe.columns assert 'exit_short' in dataframe.columns
@ -352,7 +348,7 @@ def test_deprecate_populate_indicators(result, default_conf):
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered. # Cause all warnings to always be triggered.
warnings.simplefilter("always") warnings.simplefilter("always")
strategy.advise_enter(indicators, {'pair': 'ETH/BTC'}, is_short=False) # TODO-lev strategy.advise_buy(indicators, {'pair': 'ETH/BTC'})
assert len(w) == 1 assert len(w) == 1
assert issubclass(w[-1].category, DeprecationWarning) assert issubclass(w[-1].category, DeprecationWarning)
assert "deprecated - check out the Sample strategy to see the current function headers!" \ assert "deprecated - check out the Sample strategy to see the current function headers!" \
@ -361,7 +357,7 @@ def test_deprecate_populate_indicators(result, default_conf):
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered. # Cause all warnings to always be triggered.
warnings.simplefilter("always") warnings.simplefilter("always")
strategy.advise_exit(indicators, {'pair': 'ETH_BTC'}, is_short=False) # TODO-lev strategy.advise_sell(indicators, {'pair': 'ETH_BTC'})
assert len(w) == 1 assert len(w) == 1
assert issubclass(w[-1].category, DeprecationWarning) assert issubclass(w[-1].category, DeprecationWarning)
assert "deprecated - check out the Sample strategy to see the current function headers!" \ assert "deprecated - check out the Sample strategy to see the current function headers!" \
@ -381,8 +377,6 @@ def test_call_deprecated_function(result, monkeypatch, default_conf, caplog):
assert strategy._populate_fun_len == 2 assert strategy._populate_fun_len == 2
assert strategy._buy_fun_len == 2 assert strategy._buy_fun_len == 2
assert strategy._sell_fun_len == 2 assert strategy._sell_fun_len == 2
# assert strategy._short_fun_len == 2
# assert strategy._exit_short_fun_len == 2
assert strategy.INTERFACE_VERSION == 1 assert strategy.INTERFACE_VERSION == 1
assert strategy.timeframe == '5m' assert strategy.timeframe == '5m'
assert strategy.ticker_interval == '5m' assert strategy.ticker_interval == '5m'
@ -391,22 +385,14 @@ def test_call_deprecated_function(result, monkeypatch, default_conf, caplog):
assert isinstance(indicator_df, DataFrame) assert isinstance(indicator_df, DataFrame)
assert 'adx' in indicator_df.columns assert 'adx' in indicator_df.columns
buydf = strategy.advise_enter(result, metadata=metadata, is_short=False) buydf = strategy.advise_buy(result, metadata=metadata)
assert isinstance(buydf, DataFrame) assert isinstance(buydf, DataFrame)
assert 'buy' in buydf.columns assert 'buy' in buydf.columns
selldf = strategy.advise_exit(result, metadata=metadata, is_short=False) selldf = strategy.advise_sell(result, metadata=metadata)
assert isinstance(selldf, DataFrame) assert isinstance(selldf, DataFrame)
assert 'sell' in selldf assert 'sell' in selldf
# shortdf = strategy.advise_enter(result, metadata=metadata, is_short=True)
# assert isinstance(shortdf, DataFrame)
# assert 'short' in shortdf.columns
# exit_shortdf = strategy.advise_exit(result, metadata=metadata, is_short=True)
# assert isinstance(exit_shortdf, DataFrame)
# assert 'exit_short' in exit_shortdf
assert log_has("DEPRECATED: Please migrate to using 'timeframe' instead of 'ticker_interval'.", assert log_has("DEPRECATED: Please migrate to using 'timeframe' instead of 'ticker_interval'.",
caplog) caplog)
@ -420,26 +406,18 @@ def test_strategy_interface_versioning(result, monkeypatch, default_conf):
assert strategy._populate_fun_len == 3 assert strategy._populate_fun_len == 3
assert strategy._buy_fun_len == 3 assert strategy._buy_fun_len == 3
assert strategy._sell_fun_len == 3 assert strategy._sell_fun_len == 3
assert strategy._short_fun_len == 3
assert strategy._exit_short_fun_len == 3
assert strategy.INTERFACE_VERSION == 2 assert strategy.INTERFACE_VERSION == 2
indicator_df = strategy.advise_indicators(result, metadata=metadata) indicator_df = strategy.advise_indicators(result, metadata=metadata)
assert isinstance(indicator_df, DataFrame) assert isinstance(indicator_df, DataFrame)
assert 'adx' in indicator_df.columns assert 'adx' in indicator_df.columns
buydf = strategy.advise_enter(result, metadata=metadata, is_short=False) enterdf = strategy.advise_buy(result, metadata=metadata)
assert isinstance(buydf, DataFrame) assert isinstance(enterdf, DataFrame)
assert 'buy' in buydf.columns assert 'buy' in enterdf.columns
assert 'enter_short' in enterdf.columns
selldf = strategy.advise_exit(result, metadata=metadata, is_short=False) exitdf = strategy.advise_sell(result, metadata=metadata)
assert isinstance(selldf, DataFrame) assert isinstance(exitdf, DataFrame)
assert 'sell' in selldf assert 'sell' in exitdf
assert 'exit_short' in exitdf.columns
shortdf = strategy.advise_enter(result, metadata=metadata, is_short=True)
assert isinstance(shortdf, DataFrame)
assert 'short' in shortdf.columns
exit_shortdf = strategy.advise_exit(result, metadata=metadata, is_short=True)
assert isinstance(exit_shortdf, DataFrame)
assert 'exit_short' in exit_shortdf