# --- Do not remove these libs --- import freqtrade.vendor.qtpylib.indicators as qtpylib import numpy as np import logging import talib.abstract as ta import pandas_ta as pta from freqtrade.persistence import Trade from freqtrade.strategy.interface import IStrategy from pandas import DataFrame, Series, DatetimeIndex, merge from datetime import datetime, timedelta, timezone from freqtrade.strategy import merge_informative_pair, CategoricalParameter, DecimalParameter, IntParameter, stoploss_from_open from freqtrade.exchange import timeframe_to_prev_date from functools import reduce from technical.indicators import RMI, zema, ichimoku # -------------------------------- def ha_typical_price(bars): res = (bars['ha_high'] + bars['ha_low'] + bars['ha_close']) / 3.0 return Series(index=bars.index, data=res) def EWO(dataframe, ema_length=5, ema2_length=35): df = dataframe.copy() ema1 = ta.EMA(df, timeperiod=ema_length) ema2 = ta.EMA(df, timeperiod=ema2_length) emadif = (ema1 - ema2) / df['low'] * 100 return emadif def SROC(dataframe, roclen=21, emalen=13, smooth=21): df = dataframe.copy() roc = ta.ROC(df, timeperiod=roclen) ema = ta.EMA(df, timeperiod=emalen) sroc = ta.ROC(ema, timeperiod=smooth) return sroc def range_percent_change(dataframe: DataFrame, method, length: int) -> float: """ Rolling Percentage Change Maximum across interval. :param dataframe: DataFrame The original OHLC dataframe :param method: High to Low / Open to Close :param length: int The length to look back """ if method == 'HL': return (dataframe['high'].rolling(length).max() - dataframe['low'].rolling(length).min()) / dataframe['low'].rolling(length).min() elif method == 'OC': return (dataframe['open'].rolling(length).max() - dataframe['close'].rolling(length).min()) / dataframe['close'].rolling(length).min() else: raise ValueError(f'Method {method} not defined!') # Williams %R def williams_r(dataframe: DataFrame, period: int=14) -> Series: """Williams %R, or just %R, is a technical analysis oscillator showing the current closing price in relation to the high and low of the past N days (for a given N). It was developed by a publisher and promoter of trading materials, Larry Williams. Its purpose is to tell whether a stock or commodity market is trading near the high or the low, or somewhere in between, of its recent trading range. The oscillator is on a negative scale, from −100 (lowest) up to 0 (highest). """ highest_high = dataframe['high'].rolling(center=False, window=period).max() lowest_low = dataframe['low'].rolling(center=False, window=period).min() WR = Series((highest_high - dataframe['close']) / (highest_high - lowest_low), name=f'{period} Williams %R') return WR * -100 # Chaikin Money Flow def chaikin_money_flow(dataframe, n=20, fillna=False) -> Series: """Chaikin Money Flow (CMF) It measures the amount of Money Flow Volume over a specific period. http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:chaikin_money_flow_cmf Args: dataframe(pandas.Dataframe): dataframe containing ohlcv n(int): n period. fillna(bool): if fill nan values. Returns: pandas.Series: New feature generated. """ mfv = (dataframe['close'] - dataframe['low'] - (dataframe['high'] - dataframe['close'])) / (dataframe['high'] - dataframe['low']) mfv = mfv.fillna(0.0) # float division by zero mfv *= dataframe['volume'] cmf = mfv.rolling(n, min_periods=0).sum() / dataframe['volume'].rolling(n, min_periods=0).sum() if fillna: cmf = cmf.replace([np.inf, -np.inf], np.nan).fillna(0) return Series(cmf, name='cmf') class BB_RPB_TSL(IStrategy): INTERFACE_VERSION = 3 '\n BB_RPB_TSL\n @author jilv220\n Simple bollinger brand strategy inspired by this blog ( https://hacks-for-life.blogspot.com/2020/12/freqtrade-notes.html )\n RPB, which stands for Real Pull Back, taken from ( https://github.com/GeorgeMurAlkh/freqtrade-stuff/blob/main/user_data/strategies/TheRealPullbackV2.py )\n The trailing custom stoploss taken from BigZ04_TSL from Perkmeister ( modded by ilya )\n I modified it to better suit my taste and added Hyperopt for this strategy.\n ' # (1) exit rework ########################################################################## # Hyperopt result area # entry space ## ## # ## ## ## ## ## ## ## ## ## ## ## entry_params = {'max_slip': 0.668, 'entry_bb_width_1h': 0.954, 'entry_roc_1h': 86, 'entry_threshold': 0.003, 'entry_bb_factor': 0.999, 'entry_bb_delta': 0.025, 'entry_bb_width': 0.095, 'entry_cci': -116, 'entry_cci_length': 25, 'entry_rmi': 49, 'entry_rmi_length': 17, 'entry_srsi_fk': 32, 'entry_closedelta': 17.922, 'entry_ema_diff': 0.026, 'entry_ema_high': 0.968, 'entry_ema_low': 0.935, 'entry_ewo': -5.001, 'entry_rsi': 23, 'entry_rsi_fast': 44, 'entry_ema_high_2': 1.087, 'entry_ema_low_2': 0.97, 'entry_ewo_high_2': 4.179, 'entry_rsi_ewo_2': 35, 'entry_rsi_fast_ewo_2': 45, 'entry_closedelta_local_dip': 12.044, 'entry_ema_diff_local_dip': 0.024, 'entry_ema_high_local_dip': 1.014, 'entry_rsi_local_dip': 21, 'entry_r_deadfish_bb_factor': 1.014, 'entry_r_deadfish_bb_width': 0.299, 'entry_r_deadfish_ema': 1.054, 'entry_r_deadfish_volume_factor': 1.59, 'entry_r_deadfish_cti': -0.115, 'entry_r_deadfish_r14': -44.34, 'entry_clucha_bbdelta_close': 0.049, 'entry_clucha_bbdelta_tail': 1.146, 'entry_clucha_close_bblower': 0.018, 'entry_clucha_closedelta_close': 0.017, 'entry_clucha_rocr_1h': 0.526, 'entry_adx': 13, 'entry_cofi_r14': -85.016, 'entry_cofi_cti': -0.892, 'entry_ema_cofi': 1.147, 'entry_ewo_high': 8.594, 'entry_fastd': 28, 'entry_fastk': 39, 'entry_gumbo_ema': 1.121, 'entry_gumbo_ewo_low': -9.442, 'entry_gumbo_cti': -0.374, 'entry_gumbo_r14': -51.971, 'entry_sqzmom_ema': 0.981, 'entry_sqzmom_ewo': -3.966, 'entry_sqzmom_r14': -45.068, 'entry_nfix_39_cti': -0.105, 'entry_nfix_39_r14': -81.827} # exit space ## ## ## exit_params = {'exit_cmf': -0.046, 'exit_ema': 0.988, 'exit_ema_close_delta': 0.022, 'exit_deadfish_profit': -0.063, 'exit_deadfish_bb_factor': 0.954, 'exit_deadfish_bb_width': 0.043, 'exit_deadfish_volume_factor': 2.37, 'exit_cti_r_cti': 0.844, 'exit_cti_r_r': -19.99} minimal_roi = {'0': 0.205} # Optimal timeframe for the strategy timeframe = '5m' inf_1h = '1h' # Run "populate_indicators()" only for new candle. process_only_new_candles = True # Disabled stoploss = -0.99 # Custom stoploss use_custom_stoploss = True use_exit_signal = True ############################################################################ ## Buy params is_optimize_dip = False entry_rmi = IntParameter(30, 50, default=35, optimize=is_optimize_dip) entry_cci = IntParameter(-135, -90, default=-133, optimize=is_optimize_dip) entry_srsi_fk = IntParameter(30, 50, default=25, optimize=is_optimize_dip) entry_cci_length = IntParameter(25, 45, default=25, optimize=is_optimize_dip) entry_rmi_length = IntParameter(8, 20, default=8, optimize=is_optimize_dip) is_optimize_break = False entry_bb_width = DecimalParameter(0.065, 0.135, default=0.095, optimize=is_optimize_break) entry_bb_delta = DecimalParameter(0.018, 0.035, default=0.025, optimize=is_optimize_break) is_optimize_local_uptrend = False entry_ema_diff = DecimalParameter(0.022, 0.027, default=0.025, optimize=is_optimize_local_uptrend) entry_bb_factor = DecimalParameter(0.99, 0.999, default=0.995, optimize=False) entry_closedelta = DecimalParameter(12.0, 18.0, default=15.0, optimize=is_optimize_local_uptrend) is_optimize_local_dip = False entry_ema_diff_local_dip = DecimalParameter(0.022, 0.027, default=0.025, optimize=is_optimize_local_dip) entry_ema_high_local_dip = DecimalParameter(0.9, 1.2, default=0.942, optimize=is_optimize_local_dip) entry_closedelta_local_dip = DecimalParameter(12.0, 18.0, default=15.0, optimize=is_optimize_local_dip) entry_rsi_local_dip = IntParameter(15, 45, default=28, optimize=is_optimize_local_dip) entry_crsi_local_dip = IntParameter(10, 18, default=10, optimize=False) is_optimize_ewo = False entry_rsi_fast = IntParameter(35, 50, default=45, optimize=is_optimize_ewo) entry_rsi = IntParameter(15, 35, default=35, optimize=is_optimize_ewo) entry_ewo = DecimalParameter(-6.0, 5, default=-5.585, optimize=is_optimize_ewo) entry_ema_low = DecimalParameter(0.9, 0.99, default=0.942, optimize=is_optimize_ewo) entry_ema_high = DecimalParameter(0.95, 1.2, default=1.084, optimize=is_optimize_ewo) is_optimize_ewo_2 = False entry_rsi_fast_ewo_2 = IntParameter(15, 50, default=45, optimize=is_optimize_ewo_2) entry_rsi_ewo_2 = IntParameter(15, 50, default=35, optimize=is_optimize_ewo_2) entry_ema_low_2 = DecimalParameter(0.9, 1.2, default=0.97, optimize=is_optimize_ewo_2) entry_ema_high_2 = DecimalParameter(0.9, 1.2, default=1.087, optimize=is_optimize_ewo_2) entry_ewo_high_2 = DecimalParameter(2, 12, default=4.179, optimize=is_optimize_ewo_2) is_optimize_ewo2_protection = False entry_ewo2_cti = DecimalParameter(-0.9, -0.0, default=-0.5, optimize=is_optimize_ewo2_protection) entry_ewo2_r14 = DecimalParameter(-100, -44, default=-60, optimize=is_optimize_ewo2_protection) is_optimize_r_deadfish = False entry_r_deadfish_ema = DecimalParameter(0.9, 1.2, default=1.087, optimize=is_optimize_r_deadfish) entry_r_deadfish_bb_width = DecimalParameter(0.03, 0.75, default=0.05, optimize=is_optimize_r_deadfish) entry_r_deadfish_bb_factor = DecimalParameter(0.9, 1.2, default=1.0, optimize=is_optimize_r_deadfish) entry_r_deadfish_volume_factor = DecimalParameter(1, 2.5, default=1.0, optimize=is_optimize_r_deadfish) is_optimize_r_deadfish_protection = False entry_r_deadfish_cti = DecimalParameter(-0.6, -0.0, default=-0.5, optimize=is_optimize_r_deadfish_protection) entry_r_deadfish_r14 = DecimalParameter(-60, -44, default=-60, optimize=is_optimize_r_deadfish_protection) is_optimize_clucha = False entry_clucha_bbdelta_close = DecimalParameter(0.01, 0.05, default=0.02206, optimize=is_optimize_clucha) entry_clucha_bbdelta_tail = DecimalParameter(0.7, 1.2, default=1.02515, optimize=is_optimize_clucha) entry_clucha_close_bblower = DecimalParameter(0.001, 0.05, default=0.03669, optimize=is_optimize_clucha) entry_clucha_closedelta_close = DecimalParameter(0.001, 0.05, default=0.04401, optimize=is_optimize_clucha) entry_clucha_rocr_1h = DecimalParameter(0.1, 1.0, default=0.47782, optimize=is_optimize_clucha) is_optimize_cofi = False entry_ema_cofi = DecimalParameter(0.94, 1.2, default=0.97, optimize=is_optimize_cofi) entry_fastk = IntParameter(0, 40, default=20, optimize=is_optimize_cofi) entry_fastd = IntParameter(0, 40, default=20, optimize=is_optimize_cofi) entry_adx = IntParameter(0, 30, default=30, optimize=is_optimize_cofi) entry_ewo_high = DecimalParameter(2, 12, default=3.553, optimize=is_optimize_cofi) is_optimize_cofi_protection = False entry_cofi_cti = DecimalParameter(-0.9, -0.0, default=-0.5, optimize=is_optimize_cofi_protection) entry_cofi_r14 = DecimalParameter(-100, -44, default=-60, optimize=is_optimize_cofi_protection) is_optimize_gumbo = False entry_gumbo_ema = DecimalParameter(0.9, 1.2, default=0.97, optimize=is_optimize_gumbo) entry_gumbo_ewo_low = DecimalParameter(-12.0, 5, default=-5.585, optimize=is_optimize_gumbo) is_optimize_gumbo_protection = False entry_gumbo_cti = DecimalParameter(-0.9, -0.0, default=-0.5, optimize=is_optimize_gumbo_protection) entry_gumbo_r14 = DecimalParameter(-100, -44, default=-60, optimize=is_optimize_gumbo_protection) is_optimize_sqzmom_protection = False entry_sqzmom_ema = DecimalParameter(0.9, 1.2, default=0.97, optimize=is_optimize_sqzmom_protection) entry_sqzmom_ewo = DecimalParameter(-12, 12, default=0, optimize=is_optimize_sqzmom_protection) entry_sqzmom_r14 = DecimalParameter(-100, -22, default=-50, optimize=is_optimize_sqzmom_protection) is_optimize_nfix_39_protection = False entry_nfix_39_cti = DecimalParameter(-0.9, -0.0, default=-0.5, optimize=is_optimize_nfix_39_protection) entry_nfix_39_r14 = DecimalParameter(-100, -44, default=-60, optimize=is_optimize_nfix_39_protection) is_optimize_btc_safe = False entry_btc_safe = IntParameter(-300, 50, default=-200, optimize=is_optimize_btc_safe) entry_btc_safe_1d = DecimalParameter(-0.075, -0.025, default=-0.05, optimize=is_optimize_btc_safe) entry_threshold = DecimalParameter(0.003, 0.012, default=0.008, optimize=is_optimize_btc_safe) is_optimize_check = False entry_roc_1h = IntParameter(-25, 200, default=10, optimize=is_optimize_check) entry_bb_width_1h = DecimalParameter(0.3, 2.0, default=0.3, optimize=is_optimize_check) ## Slippage params is_optimize_slip = False max_slip = DecimalParameter(0.33, 0.8, default=0.33, decimals=3, optimize=is_optimize_slip, load=True) ## Sell params exit_btc_safe = IntParameter(-400, -300, default=-365, optimize=False) is_optimize_exit_stoploss = False exit_cmf = DecimalParameter(-0.4, 0.0, default=0.0, optimize=is_optimize_exit_stoploss) exit_ema_close_delta = DecimalParameter(0.022, 0.027, default=0.024, optimize=is_optimize_exit_stoploss) exit_ema = DecimalParameter(0.97, 0.99, default=0.987, optimize=is_optimize_exit_stoploss) is_optimize_deadfish = False exit_deadfish_bb_width = DecimalParameter(0.03, 0.75, default=0.05, optimize=is_optimize_deadfish) exit_deadfish_profit = DecimalParameter(-0.15, -0.05, default=-0.05, optimize=is_optimize_deadfish) exit_deadfish_bb_factor = DecimalParameter(0.9, 1.2, default=1.0, optimize=is_optimize_deadfish) exit_deadfish_volume_factor = DecimalParameter(1, 2.5, default=1.0, optimize=is_optimize_deadfish) is_optimize_bleeding = False exit_bleeding_cti = DecimalParameter(-0.9, -0.0, default=-0.5, optimize=is_optimize_bleeding) exit_bleeding_r14 = DecimalParameter(-100, -44, default=-60, optimize=is_optimize_bleeding) exit_bleeding_volume_factor = DecimalParameter(1, 2.5, default=1.0, optimize=is_optimize_bleeding) is_optimize_cti_r = False exit_cti_r_cti = DecimalParameter(0.55, 1, default=0.5, optimize=is_optimize_cti_r) exit_cti_r_r = DecimalParameter(-15, 0, default=-20, optimize=is_optimize_cti_r) ############################################################################ def informative_pairs(self): pairs = self.dp.current_whitelist() informative_pairs = [(pair, '1h') for pair in pairs] return informative_pairs def informative_1h_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: assert self.dp, 'DataProvider is required for multiple timeframes.' # Get the informative pair informative_1h = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=self.inf_1h) # EMA informative_1h['ema_8'] = ta.EMA(informative_1h, timeperiod=8) informative_1h['ema_50'] = ta.EMA(informative_1h, timeperiod=50) informative_1h['ema_100'] = ta.EMA(informative_1h, timeperiod=100) informative_1h['ema_200'] = ta.EMA(informative_1h, timeperiod=200) # CTI informative_1h['cti'] = pta.cti(informative_1h['close'], length=20) informative_1h['cti_40'] = pta.cti(informative_1h['close'], length=40) # CRSI (3, 2, 100) crsi_closechange = informative_1h['close'] / informative_1h['close'].shift(1) crsi_updown = np.where(crsi_closechange.gt(1), 1.0, np.where(crsi_closechange.lt(1), -1.0, 0.0)) informative_1h['crsi'] = (ta.RSI(informative_1h['close'], timeperiod=3) + ta.RSI(crsi_updown, timeperiod=2) + ta.ROC(informative_1h['close'], 100)) / 3 # Williams %R informative_1h['r_96'] = williams_r(informative_1h, period=96) informative_1h['r_480'] = williams_r(informative_1h, period=480) # Bollinger bands bollinger2 = qtpylib.bollinger_bands(qtpylib.typical_price(informative_1h), window=20, stds=2) informative_1h['bb_lowerband2'] = bollinger2['lower'] informative_1h['bb_middleband2'] = bollinger2['mid'] informative_1h['bb_upperband2'] = bollinger2['upper'] informative_1h['bb_width'] = (informative_1h['bb_upperband2'] - informative_1h['bb_lowerband2']) / informative_1h['bb_middleband2'] # ROC informative_1h['roc'] = ta.ROC(dataframe, timeperiod=9) # MOMDIV mom = momdiv(informative_1h) informative_1h['momdiv_entry'] = mom['momdiv_entry'] informative_1h['momdiv_exit'] = mom['momdiv_exit'] informative_1h['momdiv_coh'] = mom['momdiv_coh'] informative_1h['momdiv_col'] = mom['momdiv_col'] # RSI informative_1h['rsi'] = ta.RSI(informative_1h, timeperiod=14) # CMF informative_1h['cmf'] = chaikin_money_flow(informative_1h, 20) # Heikin Ashi inf_heikinashi = qtpylib.heikinashi(informative_1h) informative_1h['ha_close'] = inf_heikinashi['close'] informative_1h['rocr'] = ta.ROCR(informative_1h['ha_close'], timeperiod=168) # T3 Average informative_1h['T3'] = T3(informative_1h) # Pump protections #informative_1h['hl_pct_change_48'] = range_percent_change(informative_1h, 'HL', length=48) #informative_1h['hl_pct_change_36'] = range_percent_change(informative_1h, 'HL', length=36) #informative_1h['hl_pct_change_24'] = range_percent_change(informative_1h, 'HL', length=24) #informative_1h['hl_pct_change_12'] = range_percent_change(informative_1h, 'HL', length=12) #informative_1h['hl_pct_change_6'] = range_percent_change(informative_1h, 'HL', length=6) return informative_1h ############################################################################ ### Custom functions def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime, current_rate: float, current_profit: float, **kwargs) -> float: sl_new = 1 if current_profit > 0.2: sl_new = 0.05 elif current_profit > 0.1: sl_new = 0.03 elif current_profit > 0.06: sl_new = 0.02 elif current_profit > 0.03: sl_new = 0.015 return sl_new # From NFIX def custom_exit(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float, current_profit: float, **kwargs): dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) last_candle = dataframe.iloc[-1] previous_candle_1 = dataframe.iloc[-2] max_profit = (trade.max_rate - trade.open_rate) / trade.open_rate max_loss = (trade.open_rate - trade.min_rate) / trade.min_rate enter_tag = 'empty' if hasattr(trade, 'enter_tag') and trade.entry_tag is not None: enter_tag = trade.entry_tag entry_tags = entry_tag.split() # exit trail if 0.012 > current_profit >= 0.0: if max_profit > current_profit + 0.045 and last_candle['rsi'] < 46.0: return f'exit_profit_t_0_1( {enter_tag})' elif max_profit > current_profit + 0.025 and last_candle['rsi'] < 32.0: return f'exit_profit_t_0_2( {enter_tag})' elif max_profit > current_profit + 0.05 and last_candle['rsi'] < 48.0: return f'exit_profit_t_0_3( {enter_tag})' elif 0.02 > current_profit >= 0.012: if max_profit > current_profit + 0.01 and last_candle['rsi'] < 39.0: return f'exit_profit_t_1_1( {enter_tag})' elif max_profit > current_profit + 0.035 and last_candle['rsi'] < 45.0 and (last_candle['cmf'] < -0.0) and (last_candle['cmf_1h'] < -0.0): return f'exit_profit_t_1_2( {enter_tag})' elif max_profit > current_profit + 0.02 and last_candle['rsi'] < 40.0 and (last_candle['cmf'] < -0.0) and (last_candle['cti_1h'] > 0.8): return f'exit_profit_t_1_4( {enter_tag})' elif max_profit > current_profit + 0.04 and last_candle['rsi'] < 49.0 and (last_candle['cmf_1h'] < -0.0): return f'exit_profit_t_1_5( {enter_tag})' elif max_profit > current_profit + 0.06 and last_candle['rsi'] < 43.0 and (last_candle['cmf'] < -0.0): return f'exit_profit_t_1_7( {enter_tag})' elif max_profit > current_profit + 0.025 and last_candle['rsi'] < 40.0 and (last_candle['cmf'] < -0.1) and (last_candle['rsi_1h'] < 50.0): return f'exit_profit_t_1_9( {enter_tag})' elif max_profit > current_profit + 0.025 and last_candle['rsi'] < 46.0 and (last_candle['cmf'] < -0.0) and (last_candle['r_480_1h'] > -20.0): return f'exit_profit_t_1_10( {enter_tag})' elif max_profit > current_profit + 0.025 and last_candle['rsi'] < 42.0: return f'exit_profit_t_1_11( {enter_tag})' elif max_profit > current_profit + 0.01 and last_candle['rsi'] < 44.0 and (last_candle['cmf'] < -0.25): return f'exit_profit_t_1_12( {enter_tag})' # exit cti_r if 0.012 > current_profit >= 0.0: if last_candle['cti'] > self.exit_cti_r_cti.value and last_candle['r_14'] > self.exit_cti_r_r.value: return f'exit_profit_t_cti_r_0_1( {enter_tag})' # main exit if current_profit > 0.02: if last_candle['momdiv_exit_1h'] == True: return f'signal_profit_q_momdiv_1h( {enter_tag})' if last_candle['momdiv_exit'] == True: return f'signal_profit_q_momdiv( {enter_tag})' if last_candle['momdiv_coh'] == True: return f'signal_profit_q_momdiv_coh( {enter_tag})' # exit bear if last_candle['close'] < last_candle['ema_200']: if 0.02 > current_profit >= 0.01: if last_candle['rsi'] < 34.0 and last_candle['cmf'] < 0.0: return f'exit_profit_u_bear_1_1( {enter_tag})' elif last_candle['rsi'] < 44.0 and last_candle['cmf'] < -0.4: return f'exit_profit_u_bear_1_2( {enter_tag})' # exit quick if 0.06 > current_profit > 0.02 and last_candle['rsi'] > 80.0: return f'signal_profit_q_1( {enter_tag})' if 0.06 > current_profit > 0.02 and last_candle['cti'] > 0.95: return f'signal_profit_q_2( {enter_tag})' if 0.06 > current_profit > 0.02 and last_candle['pm'] <= last_candle['pmax_thresh'] and (last_candle['close'] > last_candle['sma_21'] * 1.1): return f'signal_profit_q_pmax_bull( {enter_tag})' if 0.06 > current_profit > 0.02 and last_candle['pm'] > last_candle['pmax_thresh'] and (last_candle['close'] > last_candle['sma_21'] * 1.016): return f'signal_profit_q_pmax_bear( {enter_tag})' if current_profit < -0.05 and last_candle['close'] < last_candle['ema_200'] * 0.988 and (last_candle['cmf'] < -0.046) and ((last_candle['ema_200'] - last_candle['close']) / last_candle['close'] < 0.022) and (last_candle['rsi'] > previous_candle_1['rsi']) and (last_candle['rsi'] > last_candle['rsi_1h'] + 10.0): return f'exit_stoploss_u_e_1( {enter_tag})' # stoploss - deadfish if current_profit < self.exit_deadfish_profit.value and last_candle['close'] < last_candle['ema_200'] and (last_candle['bb_width'] < self.exit_deadfish_bb_width.value) and (last_candle['close'] > last_candle['bb_middleband2'] * self.exit_deadfish_bb_factor.value) and (last_candle['volume_mean_12'] < last_candle['volume_mean_24'] * self.exit_deadfish_volume_factor.value): return f'exit_stoploss_deadfish( {enter_tag})' # stoploss - bleeding #if ( (current_profit < -0.05) #and (last_candle['close'] < last_candle['ema_200']) #and (last_candle['cti_mean_24'] < self.exit_bleeding_cti.value) #and (last_candle['r_14_mean_24'] < self.exit_bleeding_r14.value) #and (last_candle['volume_mean_12'] < last_candle['volume_mean_24'] * self.exit_bleeding_volume_factor.value) #): #return f"exit_stoploss_bleeding( {entry_tag})" return None ## Confirm Entry def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float, time_in_force: str, **kwargs) -> bool: dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) max_slip = self.max_slip.value if len(dataframe) < 1: return False dataframe = dataframe.iloc[-1].squeeze() if rate > dataframe['close']: slippage = (rate / dataframe['close'] - 1) * 100 if slippage < max_slip: return True else: return False return True ############################################################################ def normal_tf_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: # Bollinger bands bollinger2 = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2) dataframe['bb_lowerband2'] = bollinger2['lower'] dataframe['bb_middleband2'] = bollinger2['mid'] dataframe['bb_upperband2'] = bollinger2['upper'] bollinger3 = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=3) dataframe['bb_lowerband3'] = bollinger3['lower'] dataframe['bb_middleband3'] = bollinger3['mid'] dataframe['bb_upperband3'] = bollinger3['upper'] ### Other BB checks dataframe['bb_width'] = (dataframe['bb_upperband2'] - dataframe['bb_lowerband2']) / dataframe['bb_middleband2'] dataframe['bb_delta'] = (dataframe['bb_lowerband2'] - dataframe['bb_lowerband3']) / dataframe['bb_lowerband2'] # CCI hyperopt for val in self.entry_cci_length.range: dataframe[f'cci_length_{val}'] = ta.CCI(dataframe, val) dataframe['cci'] = ta.CCI(dataframe, 26) dataframe['cci_long'] = ta.CCI(dataframe, 170) # RMI hyperopt for val in self.entry_rmi_length.range: dataframe[f'rmi_length_{val}'] = RMI(dataframe, length=val, mom=4) # SRSI hyperopt stoch = ta.STOCHRSI(dataframe, 15, 20, 2, 2) dataframe['srsi_fk'] = stoch['fastk'] dataframe['srsi_fd'] = stoch['fastd'] # BinH dataframe['closedelta'] = (dataframe['close'] - dataframe['close'].shift()).abs() # SMA dataframe['sma_9'] = ta.SMA(dataframe, timeperiod=9) dataframe['sma_15'] = ta.SMA(dataframe, timeperiod=15) dataframe['sma_21'] = ta.SMA(dataframe, timeperiod=21) dataframe['sma_28'] = ta.SMA(dataframe, timeperiod=28) dataframe['sma_30'] = ta.SMA(dataframe, timeperiod=30) dataframe['sma_75'] = ta.SMA(dataframe, timeperiod=75) # CTI dataframe['cti'] = pta.cti(dataframe['close'], length=20) # CMF dataframe['cmf'] = chaikin_money_flow(dataframe, 20) # CRSI (3, 2, 100) crsi_closechange = dataframe['close'] / dataframe['close'].shift(1) crsi_updown = np.where(crsi_closechange.gt(1), 1.0, np.where(crsi_closechange.lt(1), -1.0, 0.0)) dataframe['crsi'] = (ta.RSI(dataframe['close'], timeperiod=3) + ta.RSI(crsi_updown, timeperiod=2) + ta.ROC(dataframe['close'], 100)) / 3 # EMA dataframe['ema_8'] = ta.EMA(dataframe, timeperiod=8) dataframe['ema_12'] = ta.EMA(dataframe, timeperiod=12) dataframe['ema_13'] = ta.EMA(dataframe, timeperiod=13) dataframe['ema_16'] = ta.EMA(dataframe, timeperiod=16) dataframe['ema_20'] = ta.EMA(dataframe, timeperiod=20) dataframe['ema_26'] = ta.EMA(dataframe, timeperiod=26) dataframe['ema_50'] = ta.EMA(dataframe, timeperiod=50) dataframe['ema_100'] = ta.EMA(dataframe, timeperiod=100) dataframe['ema_200'] = ta.EMA(dataframe, timeperiod=200) # RSI dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14) dataframe['rsi_fast'] = ta.RSI(dataframe, timeperiod=4) dataframe['rsi_slow'] = ta.RSI(dataframe, timeperiod=20) # Elliot dataframe['EWO'] = EWO(dataframe, 50, 200) # Williams %R dataframe['r_14'] = williams_r(dataframe, period=14) dataframe['r_32'] = williams_r(dataframe, period=32) dataframe['r_64'] = williams_r(dataframe, period=64) dataframe['r_96'] = williams_r(dataframe, period=96) dataframe['r_480'] = williams_r(dataframe, period=480) # Volume dataframe['volume_mean_4'] = dataframe['volume'].rolling(4).mean().shift(1) dataframe['volume_mean_12'] = dataframe['volume'].rolling(12).mean().shift(1) dataframe['volume_mean_24'] = dataframe['volume'].rolling(24).mean().shift(1) # MFI dataframe['mfi'] = ta.MFI(dataframe) # Heiken Ashi heikinashi = qtpylib.heikinashi(dataframe) dataframe['ha_open'] = heikinashi['open'] dataframe['ha_close'] = heikinashi['close'] dataframe['ha_high'] = heikinashi['high'] dataframe['ha_low'] = heikinashi['low'] ## BB 40 bollinger2_40 = qtpylib.bollinger_bands(ha_typical_price(dataframe), window=40, stds=2) dataframe['bb_lowerband2_40'] = bollinger2_40['lower'] dataframe['bb_middleband2_40'] = bollinger2_40['mid'] dataframe['bb_upperband2_40'] = bollinger2_40['upper'] # ClucHA dataframe['bb_delta_cluc'] = (dataframe['bb_middleband2_40'] - dataframe['bb_lowerband2_40']).abs() dataframe['ha_closedelta'] = (dataframe['ha_close'] - dataframe['ha_close'].shift()).abs() dataframe['tail'] = (dataframe['ha_close'] - dataframe['ha_low']).abs() dataframe['ema_slow'] = ta.EMA(dataframe['ha_close'], timeperiod=50) dataframe['rocr'] = ta.ROCR(dataframe['ha_close'], timeperiod=28) # Cofi stoch_fast = ta.STOCHF(dataframe, 5, 3, 0, 3, 0) dataframe['fastd'] = stoch_fast['fastd'] dataframe['fastk'] = stoch_fast['fastk'] dataframe['adx'] = ta.ADX(dataframe) # Profit Maximizer - PMAX dataframe['pm'], dataframe['pmx'] = pmax(heikinashi, MAtype=1, length=9, multiplier=27, period=10, src=3) dataframe['source'] = (dataframe['high'] + dataframe['low'] + dataframe['open'] + dataframe['close']) / 4 dataframe['pmax_thresh'] = ta.EMA(dataframe['source'], timeperiod=9) # MOMDIV mom = momdiv(dataframe) dataframe['momdiv_entry'] = mom['momdiv_entry'] dataframe['momdiv_exit'] = mom['momdiv_exit'] dataframe['momdiv_coh'] = mom['momdiv_coh'] dataframe['momdiv_col'] = mom['momdiv_col'] # T3 Average dataframe['T3'] = T3(dataframe) # True range dataframe['trange'] = ta.TRANGE(dataframe) # KC dataframe['range_ma_28'] = ta.SMA(dataframe['trange'], 28) dataframe['kc_upperband'] = dataframe['sma_28'] + dataframe['range_ma_28'] dataframe['kc_lowerband'] = dataframe['sma_28'] - dataframe['range_ma_28'] # Linreg dataframe['hh_20'] = ta.MAX(dataframe['high'], 20) dataframe['ll_20'] = ta.MIN(dataframe['low'], 20) dataframe['avg_hh_ll_20'] = (dataframe['hh_20'] + dataframe['ll_20']) / 2 dataframe['avg_close_20'] = ta.SMA(dataframe['close'], 20) dataframe['avg_val_20'] = (dataframe['avg_hh_ll_20'] + dataframe['avg_close_20']) / 2 dataframe['linreg_val_20'] = ta.LINEARREG(dataframe['close'] - dataframe['avg_val_20'], 20, 0) return dataframe ############################################################################ def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: # The indicators for the 1h informative timeframe informative_1h = self.informative_1h_indicators(dataframe, metadata) dataframe = merge_informative_pair(dataframe, informative_1h, self.timeframe, self.inf_1h, ffill=True) # The indicators for the normal (5m) timeframe dataframe = self.normal_tf_indicators(dataframe, metadata) return dataframe def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: conditions = [] dataframe.loc[:, 'enter_tag'] = '' is_dip = (dataframe[f'rmi_length_{self.entry_rmi_length.value}'] < self.entry_rmi.value) & (dataframe[f'cci_length_{self.entry_cci_length.value}'] <= self.entry_cci.value) & (dataframe['srsi_fk'] < self.entry_srsi_fk.value) is_sqzOff = (dataframe['bb_lowerband2'] < dataframe['kc_lowerband']) & (dataframe['bb_upperband2'] > dataframe['kc_lowerband']) # from BinH is_break = (dataframe['bb_delta'] > self.entry_bb_delta.value) & (dataframe['bb_width'] > self.entry_bb_width.value) & (dataframe['closedelta'] > dataframe['close'] * self.entry_closedelta.value / 1000) & (dataframe['close'] < dataframe['bb_lowerband3'] * self.entry_bb_factor.value) # from NFI next gen, credit goes to @iterativ is_local_uptrend = (dataframe['ema_26'] > dataframe['ema_12']) & (dataframe['ema_26'] - dataframe['ema_12'] > dataframe['open'] * self.entry_ema_diff.value) & (dataframe['ema_26'].shift() - dataframe['ema_12'].shift() > dataframe['open'] / 100) & (dataframe['close'] < dataframe['bb_lowerband2'] * self.entry_bb_factor.value) & (dataframe['closedelta'] > dataframe['close'] * self.entry_closedelta.value / 1000) is_local_dip = (dataframe['ema_26'] > dataframe['ema_12']) & (dataframe['ema_26'] - dataframe['ema_12'] > dataframe['open'] * self.entry_ema_diff_local_dip.value) & (dataframe['ema_26'].shift() - dataframe['ema_12'].shift() > dataframe['open'] / 100) & (dataframe['close'] < dataframe['ema_20'] * self.entry_ema_high_local_dip.value) & (dataframe['rsi'] < self.entry_rsi_local_dip.value) & (dataframe['crsi'] > self.entry_crsi_local_dip.value) & (dataframe['closedelta'] > dataframe['close'] * self.entry_closedelta_local_dip.value / 1000) # from SMA offset is_ewo = (dataframe['rsi_fast'] < self.entry_rsi_fast.value) & (dataframe['close'] < dataframe['ema_8'] * self.entry_ema_low.value) & (dataframe['EWO'] > self.entry_ewo.value) & (dataframe['close'] < dataframe['ema_16'] * self.entry_ema_high.value) & (dataframe['rsi'] < self.entry_rsi.value) is_ewo_2 = (dataframe['ema_200_1h'] > dataframe['ema_200_1h'].shift(12)) & (dataframe['ema_200_1h'].shift(12) > dataframe['ema_200_1h'].shift(24)) & (dataframe['rsi_fast'] < self.entry_rsi_fast_ewo_2.value) & (dataframe['close'] < dataframe['ema_8'] * self.entry_ema_low_2.value) & (dataframe['EWO'] > self.entry_ewo_high_2.value) & (dataframe['close'] < dataframe['ema_16'] * self.entry_ema_high_2.value) & (dataframe['rsi'] < self.entry_rsi_ewo_2.value) # reverse deadfish is_r_deadfish = (dataframe['ema_100'] < dataframe['ema_200'] * self.entry_r_deadfish_ema.value) & (dataframe['bb_width'] > self.entry_r_deadfish_bb_width.value) & (dataframe['close'] < dataframe['bb_middleband2'] * self.entry_r_deadfish_bb_factor.value) & (dataframe['volume_mean_12'] > dataframe['volume_mean_24'] * self.entry_r_deadfish_volume_factor.value) & (dataframe['cti'] < self.entry_r_deadfish_cti.value) & (dataframe['r_14'] < self.entry_r_deadfish_r14.value) is_clucHA = (dataframe['rocr_1h'] > self.entry_clucha_rocr_1h.value) & ((dataframe['bb_lowerband2_40'].shift() > 0) & (dataframe['bb_delta_cluc'] > dataframe['ha_close'] * self.entry_clucha_bbdelta_close.value) & (dataframe['ha_closedelta'] > dataframe['ha_close'] * self.entry_clucha_closedelta_close.value) & (dataframe['tail'] < dataframe['bb_delta_cluc'] * self.entry_clucha_bbdelta_tail.value) & (dataframe['ha_close'] < dataframe['bb_lowerband2_40'].shift()) & (dataframe['ha_close'] < dataframe['ha_close'].shift()) | (dataframe['ha_close'] < dataframe['ema_slow']) & (dataframe['ha_close'] < self.entry_clucha_close_bblower.value * dataframe['bb_lowerband2'])) # Modified from cofi, credit goes to original author "slack user CofiBit" is_cofi = (dataframe['open'] < dataframe['ema_8'] * self.entry_ema_cofi.value) & qtpylib.crossed_above(dataframe['fastk'], dataframe['fastd']) & (dataframe['fastk'] < self.entry_fastk.value) & (dataframe['fastd'] < self.entry_fastd.value) & (dataframe['adx'] > self.entry_adx.value) & (dataframe['EWO'] > self.entry_ewo_high.value) & (dataframe['cti'] < self.entry_cofi_cti.value) & (dataframe['r_14'] < self.entry_cofi_r14.value) # Modified from gumbo1, creadit goes to original author @raph92 is_gumbo = (dataframe['EWO'] < self.entry_gumbo_ewo_low.value) & (dataframe['bb_middleband2_1h'] >= dataframe['T3_1h']) & (dataframe['T3'] <= dataframe['ema_8'] * self.entry_gumbo_ema.value) & (dataframe['cti'] < self.entry_gumbo_cti.value) & (dataframe['r_14'] < self.entry_gumbo_r14.value) # Modified from squeezeMomentum, credit goes to original author @LazyBear of TradingView is_sqzmom = is_sqzOff & (dataframe['linreg_val_20'].shift(2) > dataframe['linreg_val_20'].shift(1)) & (dataframe['linreg_val_20'].shift(1) < dataframe['linreg_val_20']) & (dataframe['linreg_val_20'] < 0) & (dataframe['close'] < dataframe['ema_13'] * self.entry_sqzmom_ema.value) & (dataframe['EWO'] < self.entry_sqzmom_ewo.value) & (dataframe['r_14'] < self.entry_sqzmom_r14.value) # NFI quick mode, credit goes to @iterativ is_nfi_13 = (dataframe['ema_50_1h'] > dataframe['ema_100_1h']) & (dataframe['close'] < dataframe['sma_30'] * 0.99) & (dataframe['cti'] < -0.92) & (dataframe['EWO'] < -5.585) & (dataframe['cti_1h'] < -0.88) & (dataframe['crsi_1h'] > 10.0) # NFIX 26 is_nfi_32 = (dataframe['rsi_slow'] < dataframe['rsi_slow'].shift(1)) & (dataframe['rsi_fast'] < 46) & (dataframe['rsi'] > 25.0) & (dataframe['close'] < dataframe['sma_15'] * 0.93) & (dataframe['cti'] < -0.9) is_nfi_33 = (dataframe['close'] < dataframe['ema_13'] * 0.978) & (dataframe['EWO'] > 8) & (dataframe['cti'] < -0.88) & (dataframe['rsi'] < 32) & (dataframe['r_14'] < -98.0) & (dataframe['volume'] < dataframe['volume_mean_4'] * 2.5) is_nfi_38 = (dataframe['pm'] > dataframe['pmax_thresh']) & (dataframe['close'] < dataframe['sma_75'] * 0.98) & (dataframe['EWO'] < -4.4) & (dataframe['cti'] < -0.95) & (dataframe['r_14'] < -97) & (dataframe['crsi_1h'] > 0.5) is_nfix_5 = (dataframe['ema_200_1h'] > dataframe['ema_200_1h'].shift(12)) & (dataframe['ema_200_1h'].shift(12) > dataframe['ema_200_1h'].shift(24)) & (dataframe['close'] < dataframe['sma_75'] * 0.932) & (dataframe['EWO'] > 3.6) & (dataframe['cti'] < -0.9) & (dataframe['r_14'] < -97.0) is_nfix_49 = (dataframe['ema_26'].shift(3) > dataframe['ema_12'].shift(3)) & (dataframe['ema_26'].shift(3) - dataframe['ema_12'].shift(3) > dataframe['open'].shift(3) * 0.032) & (dataframe['ema_26'].shift(9) - dataframe['ema_12'].shift(9) > dataframe['open'].shift(3) / 100) & (dataframe['close'].shift(3) < dataframe['ema_20'].shift(3) * 0.916) & (dataframe['rsi'].shift(3) < 32.5) & (dataframe['crsi'].shift(3) > 18.0) & (dataframe['cti'] < self.entry_nfix_39_cti.value) & (dataframe['r_14'] < self.entry_nfix_39_r14.value) is_additional_check = (dataframe['roc_1h'] < self.entry_roc_1h.value) & (dataframe['bb_width_1h'] < self.entry_bb_width_1h.value) ## Additional Check is_BB_checked = is_dip & is_break ## Condition Append conditions.append(is_BB_checked) # ~2.32 / 91.1% / 46.27% D dataframe.loc[is_BB_checked, 'enter_tag'] += 'bb ' conditions.append(is_local_uptrend) # ~3.28 / 92.4% / 69.72% dataframe.loc[is_local_uptrend, 'enter_tag'] += 'local_uptrend ' conditions.append(is_local_dip) # ~0.76 / 91.1% / 15.54% dataframe.loc[is_local_dip, 'enter_tag'] += 'local_dip ' conditions.append(is_ewo) # ~0.92 / 92.0% / 43.74% D dataframe.loc[is_ewo, 'enter_tag'] += 'ewo ' conditions.append(is_ewo_2) # ~2.5 / 89.6% / 33.31% D dataframe.loc[is_ewo_2, 'enter_tag'] += 'ewo2 ' conditions.append(is_r_deadfish) # ~0.99 / 86.9% / 21.93% D dataframe.loc[is_r_deadfish, 'enter_tag'] += 'r_deadfish ' conditions.append(is_clucHA) # ~6.65 / 90.8% / 55.89% D dataframe.loc[is_clucHA, 'enter_tag'] += 'clucHA ' conditions.append(is_cofi) # ~0.4 / 94.4% / 9.59% D dataframe.loc[is_cofi, 'enter_tag'] += 'cofi ' conditions.append(is_gumbo) # ~2.63 / 90.6% / 41.49% D dataframe.loc[is_gumbo, 'enter_tag'] += 'gumbo ' conditions.append(is_sqzmom) # ~3.14 / 92.4% / 64.14% D dataframe.loc[is_sqzmom, 'enter_tag'] += 'sqzmom ' conditions.append(is_nfi_13) # ~0.4 / 100% D dataframe.loc[is_nfi_13, 'enter_tag'] += 'nfi_13 ' conditions.append(is_nfi_32) # ~0.78 / 92.0 % / 37.41% D dataframe.loc[is_nfi_32, 'enter_tag'] += 'nfi_32 ' conditions.append(is_nfi_33) # ~0.11 / 100% D dataframe.loc[is_nfi_33, 'enter_tag'] += 'nfi_33 ' conditions.append(is_nfi_38) # ~1.13 / 88.5% / 31.34% D dataframe.loc[is_nfi_38, 'enter_tag'] += 'nfi_38 ' conditions.append(is_nfix_5) # ~0.25 / 97.7% / 6.53% D dataframe.loc[is_nfix_5, 'enter_tag'] += 'nfix_5 ' conditions.append(is_nfix_49) # ~0.33 / 100% / 0% D dataframe.loc[is_nfix_49, 'enter_tag'] += 'nfix_49 ' if conditions: dataframe.loc[is_additional_check & reduce(lambda x, y: x | y, conditions), 'enter_long'] = 1 return dataframe def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe.loc[dataframe['volume'] > 0, 'exit_long'] = 0 return dataframe # PMAX def pmax(df, period, multiplier, length, MAtype, src): period = int(period) multiplier = int(multiplier) length = int(length) MAtype = int(MAtype) src = int(src) mavalue = f'MA_{MAtype}_{length}' atr = f'ATR_{period}' pm = f'pm_{period}_{multiplier}_{length}_{MAtype}' pmx = f'pmX_{period}_{multiplier}_{length}_{MAtype}' # MAtype==1 --> EMA # MAtype==2 --> DEMA # MAtype==3 --> T3 # MAtype==4 --> SMA # MAtype==5 --> VIDYA # MAtype==6 --> TEMA # MAtype==7 --> WMA # MAtype==8 --> VWMA # MAtype==9 --> zema if src == 1: masrc = df['close'] elif src == 2: masrc = (df['high'] + df['low']) / 2 elif src == 3: masrc = (df['high'] + df['low'] + df['close'] + df['open']) / 4 if MAtype == 1: mavalue = ta.EMA(masrc, timeperiod=length) elif MAtype == 2: mavalue = ta.DEMA(masrc, timeperiod=length) elif MAtype == 3: mavalue = ta.T3(masrc, timeperiod=length) elif MAtype == 4: mavalue = ta.SMA(masrc, timeperiod=length) elif MAtype == 5: mavalue = VIDYA(df, length=length) elif MAtype == 6: mavalue = ta.TEMA(masrc, timeperiod=length) elif MAtype == 7: mavalue = ta.WMA(df, timeperiod=length) elif MAtype == 8: mavalue = vwma(df, length) elif MAtype == 9: mavalue = zema(df, period=length) df[atr] = ta.ATR(df, timeperiod=period) df['basic_ub'] = mavalue + multiplier / 10 * df[atr] df['basic_lb'] = mavalue - multiplier / 10 * df[atr] basic_ub = df['basic_ub'].values final_ub = np.full(len(df), 0.0) basic_lb = df['basic_lb'].values final_lb = np.full(len(df), 0.0) for i in range(period, len(df)): final_ub[i] = basic_ub[i] if basic_ub[i] < final_ub[i - 1] or mavalue[i - 1] > final_ub[i - 1] else final_ub[i - 1] final_lb[i] = basic_lb[i] if basic_lb[i] > final_lb[i - 1] or mavalue[i - 1] < final_lb[i - 1] else final_lb[i - 1] df['final_ub'] = final_ub df['final_lb'] = final_lb pm_arr = np.full(len(df), 0.0) for i in range(period, len(df)): pm_arr[i] = final_ub[i] if pm_arr[i - 1] == final_ub[i - 1] and mavalue[i] <= final_ub[i] else final_lb[i] if pm_arr[i - 1] == final_ub[i - 1] and mavalue[i] > final_ub[i] else final_lb[i] if pm_arr[i - 1] == final_lb[i - 1] and mavalue[i] >= final_lb[i] else final_ub[i] if pm_arr[i - 1] == final_lb[i - 1] and mavalue[i] < final_lb[i] else 0.0 pm = Series(pm_arr) # Mark the trend direction up/down pmx = np.where(pm_arr > 0.0, np.where(mavalue < pm_arr, 'down', 'up'), np.NaN) return (pm, pmx) # Mom DIV def momdiv(dataframe: DataFrame, mom_length: int=10, bb_length: int=20, bb_dev: float=2.0, lookback: int=30) -> DataFrame: mom: Series = ta.MOM(dataframe, timeperiod=mom_length) upperband, middleband, lowerband = ta.BBANDS(mom, timeperiod=bb_length, nbdevup=bb_dev, nbdevdn=bb_dev, matype=0) enter_long = qtpylib.crossed_below(mom, lowerband) exit_long = qtpylib.crossed_above(mom, upperband) hh = dataframe['high'].rolling(lookback).max() ll = dataframe['low'].rolling(lookback).min() coh = dataframe['high'] >= hh col = dataframe['low'] <= ll df = DataFrame({'momdiv_mom': mom, 'momdiv_upperb': upperband, 'momdiv_lowerb': lowerband, 'momdiv_entry': enter_long, 'momdiv_exit': exit_long, 'momdiv_coh': coh, 'momdiv_col': col}, index=dataframe['close'].index) return df def T3(dataframe, length=5): """ T3 Average by HPotter on Tradingview https://www.tradingview.com/script/qzoC9H1I-T3-Average/ """ df = dataframe.copy() df['xe1'] = ta.EMA(df['close'], timeperiod=length) df['xe2'] = ta.EMA(df['xe1'], timeperiod=length) df['xe3'] = ta.EMA(df['xe2'], timeperiod=length) df['xe4'] = ta.EMA(df['xe3'], timeperiod=length) df['xe5'] = ta.EMA(df['xe4'], timeperiod=length) df['xe6'] = ta.EMA(df['xe5'], timeperiod=length) b = 0.7 c1 = -b * b * b c2 = 3 * b * b + 3 * b * b * b c3 = -6 * b * b - 3 * b - 3 * b * b * b c4 = 1 + 3 * b + b * b * b + 3 * b * b df['T3Average'] = c1 * df['xe6'] + c2 * df['xe5'] + c3 * df['xe4'] + c4 * df['xe3'] return df['T3Average'] logger = logging.getLogger(__name__) class BB_RPB_TSL_Trailing(BB_RPB_TSL): # Original idea by @MukavaValkku, code by @tirail and @stash86 # # This class is designed to inherit from yours and starts trailing entry with your entry signals # Trailing entry starts at any entry signal and will move to next candles if the trailing still active # Trailing entry stops with BUY if : price decreases and rises again more than trailing_entry_offset # Trailing entry stops with NO BUY : current price is > initial price * (1 + trailing_entry_max) OR custom_exit tag # IT IS NOT COMPATIBLE WITH BACKTEST/HYPEROPT # process_only_new_candles = True custom_info_trail_entry = dict() # Trailing entry parameters trailing_entry_order_enabled = True trailing_expire_seconds = 1800 # If the current candle goes above min_uptrend_trailing_profit % before trailing_expire_seconds_uptrend seconds, entry the coin trailing_entry_uptrend_enabled = False trailing_expire_seconds_uptrend = 90 min_uptrend_trailing_profit = 0.02 debug_mode = True trailing_entry_max_stop = 0.02 # stop trailing entry if current_price > starting_price * (1+trailing_entry_max_stop) trailing_entry_max_entry = 0.0 # entry if price between uplimit (=min of serie (current_price * (1 + trailing_entry_offset())) and (start_price * 1+trailing_entry_max_entry)) init_trailing_dict = {'trailing_entry_order_started': False, 'trailing_entry_order_uplimit': 0, 'start_trailing_price': 0, 'enter_tag': None, 'start_trailing_time': None, 'offset': 0, 'allow_trailing': False} def trailing_entry(self, pair, reinit=False): # returns trailing entry info for pair (init if necessary) if not pair in self.custom_info_trail_entry: self.custom_info_trail_entry[pair] = dict() if reinit or not 'trailing_entry' in self.custom_info_trail_entry[pair]: self.custom_info_trail_entry[pair]['trailing_entry'] = self.init_trailing_dict.copy() return self.custom_info_trail_entry[pair]['trailing_entry'] def trailing_entry_info(self, pair: str, current_price: float): # current_time live, dry run current_time = datetime.now(timezone.utc) if not self.debug_mode: return trailing_entry = self.trailing_entry(pair) duration = 0 try: duration = current_time - trailing_entry['start_trailing_time'] except TypeError: duration = 0 finally: logger.info(f"pair: {pair} : start: {trailing_entry['start_trailing_price']:.4f}, duration: {duration}, current: {current_price:.4f}, uplimit: {trailing_entry['trailing_entry_order_uplimit']:.4f}, profit: {self.current_trailing_profit_ratio(pair, current_price) * 100:.2f}%, offset: {trailing_entry['offset']}") def current_trailing_profit_ratio(self, pair: str, current_price: float) -> float: trailing_entry = self.trailing_entry(pair) if trailing_entry['trailing_entry_order_started']: return (trailing_entry['start_trailing_price'] - current_price) / trailing_entry['start_trailing_price'] else: return 0 def trailing_entry_offset(self, dataframe, pair: str, current_price: float): # return rebound limit before a entry in % of initial price, function of current price # return None to stop trailing entry (will start again at next entry signal) # return 'forceentry' to force immediate entry # (example with 0.5%. initial price : 100 (uplimit is 100.5), 2nd price : 99 (no entry, uplimit updated to 99.5), 3price 98 (no entry uplimit updated to 98.5), 4th price 99 -> BUY current_trailing_profit_ratio = self.current_trailing_profit_ratio(pair, current_price) default_offset = 0.005 trailing_entry = self.trailing_entry(pair) if not trailing_entry['trailing_entry_order_started']: return default_offset # example with duration and indicators # dry run, live only last_candle = dataframe.iloc[-1] current_time = datetime.now(timezone.utc) trailing_duration = current_time - trailing_entry['start_trailing_time'] if trailing_duration.total_seconds() > self.trailing_expire_seconds: if current_trailing_profit_ratio > 0 and last_candle['enter_long'] == 1: # more than 1h, price under first signal, entry signal still active -> entry return 'forceentry' else: # wait for next signal return None elif self.trailing_entry_uptrend_enabled and trailing_duration.total_seconds() < self.trailing_expire_seconds_uptrend and (current_trailing_profit_ratio < -1 * self.min_uptrend_trailing_profit): # less than 90s and price is rising, entry return 'forceentry' if current_trailing_profit_ratio < 0: # current price is higher than initial price return default_offset trailing_entry_offset = {0.06: 0.02, 0.03: 0.01, 0: default_offset} for key in trailing_entry_offset: if current_trailing_profit_ratio > key: return trailing_entry_offset[key] return default_offset # end of trailing entry parameters # ----------------------------------------------------- def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe = super().populate_indicators(dataframe, metadata) self.trailing_entry(metadata['pair']) return dataframe def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float, time_in_force: str, **kwargs) -> bool: val = super().confirm_trade_entry(pair, order_type, amount, rate, time_in_force, **kwargs) if val: if self.trailing_entry_order_enabled and self.config['runmode'].value in ('live', 'dry_run'): val = False dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) if len(dataframe) >= 1: last_candle = dataframe.iloc[-1].squeeze() current_price = rate trailing_entry = self.trailing_entry(pair) trailing_entry_offset = self.trailing_entry_offset(dataframe, pair, current_price) if trailing_entry['allow_trailing']: if not trailing_entry['trailing_entry_order_started'] and last_candle['enter_long'] == 1: # start trailing entry # self.custom_info_trail_entry[pair]['trailing_entry']['trailing_entry_order_started'] = True # self.custom_info_trail_entry[pair]['trailing_entry']['trailing_entry_order_uplimit'] = last_candle['close'] # self.custom_info_trail_entry[pair]['trailing_entry']['start_trailing_price'] = last_candle['close'] # self.custom_info_trail_entry[pair]['trailing_entry']['entry_tag'] = f"initial_entry_tag (strat trail price {last_candle['close']})" # self.custom_info_trail_entry[pair]['trailing_entry']['start_trailing_time'] = datetime.now(timezone.utc) # self.custom_info_trail_entry[pair]['trailing_entry']['offset'] = 0 trailing_entry['trailing_entry_order_started'] = True trailing_entry['trailing_entry_order_uplimit'] = last_candle['close'] trailing_entry['start_trailing_price'] = last_candle['close'] trailing_entry['enter_tag'] = last_candle['enter_tag'] trailing_entry['start_trailing_time'] = datetime.now(timezone.utc) trailing_entry['offset'] = 0 self.trailing_entry_info(pair, current_price) logger.info(f"start trailing entry for {pair} at {last_candle['close']}") elif trailing_entry['trailing_entry_order_started']: if trailing_entry_offset == 'forceentry': # entry in custom conditions val = True ratio = '%.2f' % (self.current_trailing_profit_ratio(pair, current_price) * 100) self.trailing_entry_info(pair, current_price) logger.info(f'price OK for {pair} ({ratio} %, {current_price}), order may not be triggered if all slots are full') elif trailing_entry_offset is None: # stop trailing entry custom conditions self.trailing_entry(pair, reinit=True) logger.info(f'STOP trailing entry for {pair} because "trailing entry offset" returned None') elif current_price < trailing_entry['trailing_entry_order_uplimit']: # update uplimit old_uplimit = trailing_entry['trailing_entry_order_uplimit'] self.custom_info_trail_entry[pair]['trailing_entry']['trailing_entry_order_uplimit'] = min(current_price * (1 + trailing_entry_offset), self.custom_info_trail_entry[pair]['trailing_entry']['trailing_entry_order_uplimit']) self.custom_info_trail_entry[pair]['trailing_entry']['offset'] = trailing_entry_offset self.trailing_entry_info(pair, current_price) logger.info(f"update trailing entry for {pair} at {old_uplimit} -> {self.custom_info_trail_entry[pair]['trailing_entry']['trailing_entry_order_uplimit']}") elif current_price < trailing_entry['start_trailing_price'] * (1 + self.trailing_entry_max_entry): # entry ! current price > uplimit && lower thant starting price val = True ratio = '%.2f' % (self.current_trailing_profit_ratio(pair, current_price) * 100) self.trailing_entry_info(pair, current_price) logger.info(f"current price ({current_price}) > uplimit ({trailing_entry['trailing_entry_order_uplimit']}) and lower than starting price price ({trailing_entry['start_trailing_price'] * (1 + self.trailing_entry_max_entry)}). OK for {pair} ({ratio} %), order may not be triggered if all slots are full") elif current_price > trailing_entry['start_trailing_price'] * (1 + self.trailing_entry_max_stop): # stop trailing entry because price is too high self.trailing_entry(pair, reinit=True) self.trailing_entry_info(pair, current_price) logger.info(f'STOP trailing entry for {pair} because of the price is higher than starting price * {1 + self.trailing_entry_max_stop}') else: # uplimit > current_price > max_price, continue trailing and wait for the price to go down self.trailing_entry_info(pair, current_price) logger.info(f'price too high for {pair} !') else: logger.info(f'Wait for next entry signal for {pair}') if val == True: self.trailing_entry_info(pair, rate) self.trailing_entry(pair, reinit=True) logger.info(f'STOP trailing entry for {pair} because I entry it') return val def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe = super().populate_entry_trend(dataframe, metadata) if self.trailing_entry_order_enabled and self.config['runmode'].value in ('live', 'dry_run'): last_candle = dataframe.iloc[-1].squeeze() trailing_entry = self.trailing_entry(metadata['pair']) if last_candle['enter_long'] == 1: if not trailing_entry['trailing_entry_order_started']: open_trades = Trade.get_trades([Trade.pair == metadata['pair'], Trade.is_open.is_(True)]).all() if not open_trades: logger.info(f"Set 'allow_trailing' to True for {metadata['pair']} to start trailing!!!") # self.custom_info_trail_entry[metadata['pair']]['trailing_entry']['allow_trailing'] = True trailing_entry['allow_trailing'] = True initial_entry_tag = last_candle['enter_tag'] if 'enter_tag' in last_candle else 'entry signal' dataframe.loc[:, 'enter_tag'] = f"{initial_entry_tag} (start trail price {last_candle['close']})" elif trailing_entry['trailing_entry_order_started'] == True: logger.info(f"Continue trailing for {metadata['pair']}. Manually trigger entry signal!!") dataframe.loc[:, 'enter_long'] = 1 dataframe.loc[:, 'enter_tag'] = trailing_entry['enter_tag'] # dataframe['entry'] = 1 return dataframe