def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe['maShort'] = ta.EMA(dataframe, timeperiod=8)
dataframe['maMedium'] = ta.EMA(dataframe, timeperiod=21)
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe = self.resample(dataframe, self.ticker_interval,
self.resample_factor)
dataframe['ema_high'] = ta.EMA(dataframe, timeperiod=5, price='high')
dataframe['ema_close'] = ta.EMA(dataframe, timeperiod=5, price='close')
dataframe['ema_low'] = ta.EMA(dataframe, timeperiod=5, price='low')
stoch_fast = ta.STOCHF(dataframe, 5.0, 3.0, 0.0, 3.0, 0.0)
dataframe['fastd'] = stoch_fast['fastd']
dataframe['fastk'] = stoch_fast['fastk']
dataframe['adx'] = ta.ADX(dataframe)
dataframe['cci'] = ta.CCI(dataframe, timeperiod=20)
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
dataframe['mfi'] = ta.MFI(dataframe)
# required for graphing
bollinger = qtpylib.bollinger_bands(dataframe['close'],
window=20,
stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_upperband'] = bollinger['upper']
dataframe['bb_middleband'] = bollinger['mid']
return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
from technical.util import resample_to_interval
from technical.util import resampled_merge
dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
# EMA - Exponential Moving Average
dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['ema200'] = ta.EMA(dataframe, timeperiod=200)
# resample our dataframes
dataframe_short = resample_to_interval(dataframe,
self.get_ticker_indicator() * 3)
dataframe_long = resample_to_interval(dataframe,
self.get_ticker_indicator() * 7)
# compute our RSI's
dataframe_short['rsi'] = ta.RSI(dataframe_short, timeperiod=14)
dataframe_long['rsi'] = ta.RSI(dataframe_long, timeperiod=14)
# merge dataframe back together
dataframe = resampled_merge(dataframe, dataframe_short)
dataframe = resampled_merge(dataframe, dataframe_long)
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
dataframe.fillna(method='ffill', inplace=True)
#print("rsi - {:.2f}, rsi_15 - {:.2f}, rsi_35 - {:.2f}".format(dataframe['rsi'].iloc[-1], dataframe['rsi_x'].iloc[-1], dataframe['rsi_y'].iloc[-1]))
#print(dataframe.iloc[-1])
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
# Set Up Bollinger Bands
upper_bb1, mid_bb1, lower_bb1 = ta.BBANDS(dataframe['close'],
timeperiod=40)
upper_bb2, mid_bb2, lower_bb2 = ta.BBANDS(
qtpylib.typical_price(dataframe), timeperiod=20)
# only putting some bands into dataframe as the others are not used elsewhere in the strategy
dataframe['lower-bb1'] = lower_bb1
dataframe['lower-bb2'] = lower_bb2
dataframe['mid-bb2'] = mid_bb2
dataframe['bb1-delta'] = (mid_bb1 - dataframe['lower-bb1']).abs()
dataframe['closedelta'] = (dataframe['close'] -
dataframe['close'].shift()).abs()
dataframe['tail'] = (dataframe['close'] - dataframe['low']).abs()
dataframe['ema_fast'] = ta.EMA(dataframe['close'], timeperiod=6)
dataframe['ema_slow'] = ta.EMA(dataframe['close'], timeperiod=48)
dataframe['volume_mean_slow'] = dataframe['volume'].rolling(
window=24).mean()
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=9)
# # Inverse Fisher transform on RSI: values [-1.0, 1.0] (https://goo.gl/2JGGoy)
rsi = 0.1 * (dataframe['rsi'] - 50)
dataframe['fisher-rsi'] = (np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1)
return dataframe
def normal_tf_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
# strategy BinHV45
bb_40 = qtpylib.bollinger_bands(dataframe['close'], window=40, stds=2)
dataframe['lower'] = bb_40['lower']
dataframe['mid'] = bb_40['mid']
dataframe['bbdelta'] = (bb_40['mid'] - dataframe['lower']).abs()
dataframe['closedelta'] = (dataframe['close'] - dataframe['close'].shift()).abs()
dataframe['tail'] = (dataframe['close'] - dataframe['low']).abs()
# strategy ClucMay72018
bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_middleband'] = bollinger['mid']
dataframe['bb_upperband'] = bollinger['upper']
dataframe['ema_slow'] = ta.EMA(dataframe, timeperiod=50)
dataframe['volume_mean_slow'] = dataframe['volume'].rolling(window=30).mean()
# EMA
dataframe['ema_50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['ema_200'] = ta.EMA(dataframe, timeperiod=200)
# SMA
dataframe['sma_5'] = ta.EMA(dataframe, timeperiod=5)
# RSI
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
return dataframe
def slow_tf_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe5m = self.dp.get_pair_dataframe(pair=metadata['pair'],
timeframe="5m")
create_ichimoku(dataframe5m,
conversion_line_period=355,
displacement=880,
base_line_periods=175,
laggin_span=175)
dataframe5m['hma888'] = ftt.hull_moving_average(dataframe5m, 888)
dataframe = merge_informative_pair(dataframe,
dataframe5m,
self.timeframe,
"5m",
ffill=True)
dataframe['hma100'] = ftt.hull_moving_average(dataframe, 100)
dataframe['ema550'] = ta.EMA(dataframe, timeperiod=550)
dataframe['ema633'] = ta.EMA(dataframe, timeperiod=633)
create_ichimoku(dataframe,
conversion_line_period=20,
displacement=88,
base_line_periods=88,
laggin_span=88)
create_ichimoku(dataframe,
conversion_line_period=9,
displacement=26,
base_line_periods=26,
laggin_span=52)
create_ichimoku(dataframe,
conversion_line_period=444,
displacement=444,
base_line_periods=444,
laggin_span=444)
create_ichimoku(dataframe,
conversion_line_period=355,
displacement=888,
base_line_periods=175,
laggin_span=175)
dataframe['ichimoku_ok'] = (
(dataframe['kijun_sen_355_5m'] >= dataframe['tenkan_sen_355_5m']) &
(dataframe['kijun_sen_20'] > dataframe['tenkan_sen_444']) &
(dataframe['senkou_a_9'] > dataframe['senkou_a_20']) &
(dataframe['tenkan_sen_20'] >= dataframe['kijun_sen_20']) &
(dataframe['tenkan_sen_9'] >= dataframe['tenkan_sen_20']) &
(dataframe['tenkan_sen_9'] >= dataframe['kijun_sen_9'])
).astype('int') * 4
dataframe['trending_over'] = ((dataframe['senkou_b_355_5m'] >
dataframe['close'])).astype('int') * 1
dataframe.loc[(dataframe['ichimoku_ok'] > 0), 'trending'] = 3
dataframe.loc[(dataframe['trending_over'] > 0), 'trending'] = 0
dataframe['trending'].fillna(method='ffill', inplace=True)
return dataframe
def populate_sell_trend(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
conditions = []
# GUARDS
if self.sell_rsi_enabled.value:
conditions.append(dataframe['rsi'] > self.sell_rsi.value)
if self.sell_mfi_enabled.value:
conditions.append(dataframe['mfi'] > self.sell_mfi.value)
if self.sell_ema_enabled.value:
try:
conditions.append(
ta.EMA(dataframe, timeperiod=int(self.sell_fastema.value))
< ta.EMA(dataframe,
timeperiod=int(self.sell_slowema.value)))
except Exception:
pass
# TRIGGERS
if self.sell_trigger.value == 'sell-bb_upper1':
conditions.append(dataframe["close"] > dataframe['bb_upperband1'])
if self.sell_trigger.value == 'sell-bb_upper2':
conditions.append(dataframe["close"] > dataframe['bb_upperband2'])
if self.sell_trigger.value == 'sell-bb_upper3':
conditions.append(dataframe["close"] > dataframe['bb_upperband3'])
if self.sell_trigger.value == 'sell-bb_upper4':
conditions.append(dataframe["close"] > dataframe['bb_upperband4'])
# Check that volume is not 0
conditions.append(dataframe['volume'] > 0)
if conditions:
dataframe.loc[reduce(lambda x, y: x & y, conditions), 'sell'] = 1
return dataframe
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
dataframe['rsi'] = numpy.nan_to_num(ta.RSI(dataframe, timeperiod=5))
dataframe['emarsi'] = numpy.nan_to_num(ta.EMA(dataframe['rsi'], timeperiod=5))
dataframe['adx'] = numpy.nan_to_num(ta.ADX(dataframe))
dataframe['minusdi'] = numpy.nan_to_num(ta.MINUS_DI(dataframe))
dataframe['minusdiema'] = numpy.nan_to_num(ta.EMA(dataframe['minusdi'], timeperiod=25))
dataframe['plusdi'] = numpy.nan_to_num(ta.PLUS_DI(dataframe))
dataframe['plusdiema'] = numpy.nan_to_num(ta.EMA(dataframe['plusdi'], timeperiod=5))
dataframe['lowsma'] = numpy.nan_to_num(ta.EMA(dataframe, timeperiod=60))
dataframe['highsma'] = numpy.nan_to_num(ta.EMA(dataframe, timeperiod=120))
dataframe['fastsma'] = numpy.nan_to_num(ta.SMA(dataframe, timeperiod=120))
dataframe['slowsma'] = numpy.nan_to_num(ta.SMA(dataframe, timeperiod=240))
dataframe['bigup'] = dataframe['fastsma'].gt(dataframe['slowsma']) & ((dataframe['fastsma'] - dataframe['slowsma']) > dataframe['close'] / 300)
dataframe['bigdown'] = ~dataframe['bigup']
dataframe['trend'] = dataframe['fastsma'] - dataframe['slowsma']
dataframe['preparechangetrend'] = dataframe['trend'].gt(dataframe['trend'].shift())
dataframe['preparechangetrendconfirm'] = dataframe['preparechangetrend'] & dataframe['trend'].shift().gt(dataframe['trend'].shift(2))
dataframe['continueup'] = dataframe['slowsma'].gt(dataframe['slowsma'].shift()) & dataframe['slowsma'].shift().gt(dataframe['slowsma'].shift(2))
dataframe['delta'] = dataframe['fastsma'] - dataframe['fastsma'].shift()
dataframe['slowingdown'] = dataframe['delta'].lt(dataframe['delta'].shift())
return dataframe
def mac(self,
dataframe: DataFrame,
fast: int = 20,
slow: int = 50) -> Series:
dataframe = dataframe.copy()
# Fast MAs
upper_fast = ta.EMA(dataframe['high'], timeperiod=fast)
lower_fast = ta.EMA(dataframe['low'], timeperiod=fast)
# Slow MAs
upper_slow = ta.EMA(dataframe['high'], timeperiod=slow)
lower_slow = ta.EMA(dataframe['low'], timeperiod=slow)
# Crosses
crosses_lf_us = qtpylib.crossed_above(
lower_fast, upper_slow) | qtpylib.crossed_below(
lower_fast, upper_slow)
crosses_uf_ls = qtpylib.crossed_above(
upper_fast, lower_slow) | qtpylib.crossed_below(
upper_fast, lower_slow)
dir_1 = np.where(crosses_lf_us, 1, np.nan)
dir_2 = np.where(crosses_uf_ls, -1, np.nan)
dir = np.where(dir_1 == 1, dir_1, np.nan)
dir = np.where(dir_2 == -1, dir_2, dir_1)
res = Series(dir).fillna(method='ffill').to_numpy()
return res
def normal_tf_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_middleband'] = bollinger['mid']
dataframe['bb_upperband'] = bollinger['upper']
dataframe['volume_mean_slow'] = dataframe['volume'].rolling(window=48).mean()
# EMA
dataframe['ema_200'] = ta.EMA(dataframe, timeperiod=200)
dataframe['ema_26'] = ta.EMA(dataframe, timeperiod=26)
dataframe['ema_12'] = ta.EMA(dataframe, timeperiod=12)
# MACD
dataframe['macd'], dataframe['signal'], dataframe['hist'] = ta.MACD(dataframe['close'], fastperiod=12, slowperiod=26, signalperiod=9)
# SMA
dataframe['sma_5'] = ta.EMA(dataframe, timeperiod=5)
# RSI
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
# ------ ATR stuff
dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
# Calculate all ma_sell values
for val in self.base_nb_candles_sell.range:
dataframe[f'ma_sell_{val}'] = ta.EMA(dataframe, timeperiod=val)
return dataframe
def generate_technical_indicators(pair_df):
"""
Builds dataframe containing Time and indicators such as 10-day and 50-day EMAs,
RSI, and A/D index. Also uses differencing to remove seasonality trends.
Args:
pair_df: Dataframe containing "Time" column and columns for ohlc data
Returns:
Dataframe containing technical indicator data for a specific currency pair
"""
pair_df["EMA_10"] = pd.DataFrame(abstract.EMA(
pair_df["Close"], timeperiod=10)) # 960))
pair_df["EMA_50"] = pd.DataFrame(abstract.EMA(
pair_df["Close"], timeperiod=50)) # 4800))
pair_df["RSI"] = pd.DataFrame(
abstract.RSI(pair_df["Close"], timeperiod=14))
pair_df["A/D Index"] = pd.DataFrame(
abstract.AD(
pair_df["High"], pair_df["Low"], pair_df["Close"], pair_df["Volume"]
)
)
# Take difference to remove trends
pair_df["A/D Index"] = pair_df["A/D Index"] - pair_df["A/D Index"].shift(1)
pair_df = stationary_log_returns(pair_df)
return pair_df
def HA(self, dataframe, smoothing=None):
df = dataframe.copy()
df['HA_Close'] = (df['open'] + df['high'] + df['low'] +
df['close']) / 4
df.reset_index(inplace=True)
ha_open = [(df['open'][0] + df['close'][0]) / 2]
[
ha_open.append((ha_open[i] + df['HA_Close'].values[i]) / 2)
for i in range(0,
len(df) - 1)
]
df['HA_Open'] = ha_open
df.set_index('index', inplace=True)
df['HA_High'] = df[['HA_Open', 'HA_Close', 'high']].max(axis=1)
df['HA_Low'] = df[['HA_Open', 'HA_Close', 'low']].min(axis=1)
if smoothing is not None:
sml = abs(int(smoothing))
if sml > 0:
df['Smooth_HA_O'] = ta.EMA(df['HA_Open'], sml)
df['Smooth_HA_C'] = ta.EMA(df['HA_Close'], sml)
df['Smooth_HA_H'] = ta.EMA(df['HA_High'], sml)
df['Smooth_HA_L'] = ta.EMA(df['HA_Low'], sml)
return df
def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
macd = ta.MACD(dataframe)
dataframe['maShort'] = ta.EMA(dataframe, timeperiod=8)
dataframe['maMedium'] = ta.EMA(dataframe, timeperiod=21)
return dataframe
def populate_indicators(dataframe: DataFrame) -> DataFrame:
"""
Adds several different TA indicators to the given DataFrame
"""
dataframe['sar'] = ta.SAR(dataframe)
dataframe['adx'] = ta.ADX(dataframe)
stoch = ta.STOCHF(dataframe)
dataframe['fastd'] = stoch['fastd']
dataframe['fastk'] = stoch['fastk']
dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2,
nbdevdn=2)['lowerband']
dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
dataframe['mfi'] = ta.MFI(dataframe)
dataframe['cci'] = ta.CCI(dataframe)
dataframe['rsi'] = ta.RSI(dataframe)
dataframe['mom'] = ta.MOM(dataframe)
dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
dataframe['ao'] = awesome_oscillator(dataframe)
macd = ta.MACD(dataframe)
dataframe['macd'] = macd['macd']
dataframe['macdsignal'] = macd['macdsignal']
dataframe['macdhist'] = macd['macdhist']
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
tf_res = timeframe_to_minutes(self.timeframe) * 5
df_res = resample_to_interval(dataframe, tf_res)
df_res['sma'] = ta.SMA(df_res, 50, price='close')
dataframe = resampled_merge(dataframe, df_res, fill_na=True)
dataframe['resample_sma'] = dataframe[f'resample_{tf_res}_sma']
dataframe['ema_high'] = ta.EMA(dataframe, timeperiod=5, price='high')
dataframe['ema_close'] = ta.EMA(dataframe, timeperiod=5, price='close')
dataframe['ema_low'] = ta.EMA(dataframe, timeperiod=5, price='low')
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)
dataframe['cci'] = ta.CCI(dataframe, timeperiod=20)
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
dataframe['mfi'] = ta.MFI(dataframe)
# required for graphing
bollinger = qtpylib.bollinger_bands(dataframe['close'],
window=20,
stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_upperband'] = bollinger['upper']
dataframe['bb_middleband'] = bollinger['mid']
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
# WAVETREND
try:
ap = (dataframe['high'] + dataframe['low'] +
dataframe['close']) / 3
esa = ta.EMA(ap, 10)
d = ta.EMA((ap - esa).abs(), 10)
ci = (ap - esa).div(0.0015 * d)
tci = ta.EMA(ci, 21)
wt1 = tci
wt2 = ta.SMA(np.nan_to_num(wt1), 4)
dataframe['wt1'], dataframe['wt2'] = wt1, wt2
stoch = ta.STOCH(dataframe, 14)
slowk = stoch['slowk']
dataframe['slowk'] = slowk
# print(dataframe.iloc[:, 6:].keys())
x = dataframe.iloc[:, 6:].values # returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled = min_max_scaler.fit_transform(x)
dataframe.iloc[:, 6:] = pd.DataFrame(x_scaled)
# print('wt:\t', dataframe['wt'].min(), dataframe['wt'].max())
# print('stoch:\t', dataframe['stoch'].min(), dataframe['stoch'].max())
dataframe['def'] = dataframe['slowk'] - dataframe['wt1']
# print('def:\t', dataframe['def'].min(), "\t", dataframe['def'].max())
except:
dataframe['wt1'], dataframe['wt2'], dataframe['def'], dataframe[
'slowk'] = 0, 10, 100, 1000
return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
dataframe['ema_high'] = ta.EMA(dataframe, timeperiod=5, price='high')
dataframe['ema_close'] = ta.EMA(dataframe, timeperiod=5, price='close')
dataframe['ema_low'] = ta.EMA(dataframe, timeperiod=5, price='low')
stoch_fast = ta.STOCHF(dataframe, 5.0, 3.0, 0.0, 3.0, 0.0)
dataframe['fastd'] = stoch_fast['fastd']
dataframe['fastk'] = stoch_fast['fastk']
dataframe['adx'] = ta.ADX(dataframe)
dataframe['cci'] = ta.CCI(dataframe, timeperiod=20)
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
dataframe['mfi'] = ta.MFI(dataframe)
# required for graphing
bollinger = qtpylib.bollinger_bands(dataframe['close'],
window=20,
stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_upperband'] = bollinger['upper']
dataframe['bb_middleband'] = bollinger['mid']
macd = ta.MACD(dataframe)
dataframe['macd'] = macd['macd']
dataframe['macdsignal'] = macd['macdsignal']
dataframe['macdhist'] = macd['macdhist']
dataframe['cci'] = ta.CCI(dataframe)
return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
""" Adds several different TA indicators to the given DataFrame
"""
dataframe['ema_{}'.format(self.EMA_SHORT_TERM)] = ta.EMA(
dataframe, timeperiod=self.EMA_SHORT_TERM
)
dataframe['ema_{}'.format(self.EMA_MEDIUM_TERM)] = ta.EMA(
dataframe, timeperiod=self.EMA_MEDIUM_TERM
)
dataframe['ema_{}'.format(self.EMA_LONG_TERM)] = ta.EMA(
dataframe, timeperiod=self.EMA_LONG_TERM
)
bollinger = qtpylib.bollinger_bands(
qtpylib.typical_price(dataframe), window=20, stds=2
)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_middleband'] = bollinger['mid']
dataframe['bb_upperband'] = bollinger['upper']
dataframe['min'] = ta.MIN(dataframe, timeperiod=self.EMA_MEDIUM_TERM)
dataframe['max'] = ta.MAX(dataframe, timeperiod=self.EMA_MEDIUM_TERM)
return dataframe
def market_cipher(self, dataframe) -> DataFrame:
#dataframe['volume_rolling'] = dataframe['volume'].shift(14).rolling(14).mean()
#
osLevel = -60
obLevel = 30
dataframe['ap'] = (dataframe['high'] + dataframe['low'] +
dataframe['close']) / 3
dataframe['esa'] = ta.EMA(dataframe['ap'], self.n1)
dataframe['d'] = ta.EMA((dataframe['ap'] - dataframe['esa']).abs(),
self.n1)
dataframe['ci'] = (dataframe['ap'] -
dataframe['esa']) / (0.015 * dataframe['d'])
dataframe['tci'] = ta.EMA(dataframe['ci'], self.n2)
dataframe['wt1'] = dataframe['tci']
dataframe['wt2'] = ta.SMA(dataframe['wt1'], 4)
dataframe['wtVwap'] = dataframe['wt1'] - dataframe['wt2']
dataframe['wtOversold'] = dataframe['wt2'] <= osLevel
dataframe['wtOverbought'] = dataframe['wt2'] >= obLevel
dataframe['wtCrossUp'] = dataframe['wt2'] - dataframe['wt1'] <= 0
dataframe['wtCrossDown'] = dataframe['wt2'] - dataframe['wt1'] >= 0
dataframe['crossed_above'] = qtpylib.crossed_above(
dataframe['wt2'], dataframe['wt1'])
dataframe['crossed_below'] = qtpylib.crossed_below(
dataframe['wt2'], dataframe['wt1'])
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
"""
Adds several different TA indicators to the given DataFrame
Performance Note: For the best performance be frugal on the number of indicators
you are using. Let uncomment only the indicator you are using in your strategies
or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
"""
dataframe['ema20'] = ta.EMA(dataframe, timeperiod=20)
dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
if self.dp:
# Get ohlcv data for informative pair at 15m interval.
inf_tf = '15m'
informative = self.dp.get_pair_dataframe(pair=f"BTC/USDT",
timeframe=inf_tf)
# calculate SMA20 on informative pair
informative['sma20'] = informative['close'].rolling(20).mean()
# Combine the 2 dataframe
# This will result in a column named 'closeETH' or 'closeBTC' - depending on stake_currency.
dataframe = merge_informative_pair(dataframe,
informative,
self.timeframe,
inf_tf,
ffill=True)
return dataframe
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Adds several different TA indicators to the given DataFrame
Performance Note: For the best performance be frugal on the number of indicators
you are using. Let uncomment only the indicator you are using in your strategies
or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
"""
dataframe['ema20'] = ta.EMA(dataframe, timeperiod=20)
dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
if self.dp:
if self.dp.runmode in('live', 'dry_run'):
# Compare stake-currency with USDT - using the defined ticker-interval
if (f"{self.stake_currency}/USDT", self.ticker_interval) in self.dp.available_pairs:
data = self.dp.ohlcv(pair='ETH/BTC',
ticker_interval=self.ticker_interval)
else:
# Get historic ohlcv data (cached on disk).
# data = parse_ticker_dataframe(self.dp.historic_ohlcv(pair='ETH/BTC',
# ticker_interval=self.ticker_interval), "5m")
data = self.dp.historic_ohlcv(pair=f"{self.stake_currency}/USDT",
ticker_interval=self.ticker_interval)
if len(data) == 0:
logger.warning(f"No data found for {self.stake_currency}/USDT")
# Combine the 2 dataframes using close
# this will result in a column named closeETH or closeBTC - depnding on stake_currency.
dataframe = dataframe.merge(data[["date", "close"]], on="date", how="left", suffixes=("", self.config['stake_currency']))
# Calculate SMA20 on stakecurrency. Resulting column = smaETH20
dataframe[f"sma{self.config['stake_currency']}20"] = dataframe[f'close{self.stake_currency}'].rolling(20).mean()
return dataframe
def market_cipher(self, dataframe) -> DataFrame:
self.n1 = 10 #WT Channel Length
self.n2 = 21 #WT Average Length
dataframe['ap'] = (dataframe['high'] + dataframe['low'] +
dataframe['close']) / 3
dataframe['esa'] = ta.EMA(dataframe['ap'], self.n1)
dataframe['d'] = ta.EMA((dataframe['ap'] - dataframe['esa']).abs(),
self.n1)
dataframe['ci'] = (dataframe['ap'] -
dataframe['esa']) / (0.015 * dataframe['d'])
dataframe['tci'] = ta.EMA(dataframe['ci'], self.n2)
dataframe['wt1'] = dataframe['tci']
dataframe['wt2'] = ta.SMA(dataframe['wt1'], 4)
dataframe['wtVwap'] = dataframe['wt1'] - dataframe['wt2']
dataframe['wtCrossUp'] = dataframe['wt2'] - dataframe['wt1'] <= 0
dataframe['wtCrossDown'] = dataframe['wt2'] - dataframe['wt1'] >= 0
dataframe['crossed_above'] = qtpylib.crossed_above(
dataframe['wt2'], dataframe['wt1'])
dataframe['crossed_below'] = qtpylib.crossed_below(
dataframe['wt2'], dataframe['wt1'])
return dataframe
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
ichimoku = ftt.ichimoku(dataframe,
conversion_line_period=20,
base_line_periods=60,
laggin_span=120,
displacement=30
)
# cross indicators
dataframe['tenkan_sen'] = ichimoku['tenkan_sen']
dataframe['kijun_sen'] = ichimoku['kijun_sen']
# cloud, green a > b, red a < b
dataframe['senkou_a'] = ichimoku['senkou_span_a']
dataframe['senkou_b'] = ichimoku['senkou_span_b']
# dataframe['leading_senkou_span_a'] = ichimoku['leading_senkou_span_a']
# dataframe['leading_senkou_span_b'] = ichimoku['leading_senkou_span_b']
dataframe['cloud_green'] = ichimoku['cloud_green'] * 1
dataframe['cloud_red'] = ichimoku['cloud_red'] * -1
dataframe['cloud_green_strong'] = (
dataframe['cloud_green'] &
(dataframe['tenkan_sen'] > dataframe['kijun_sen']) &
(dataframe['kijun_sen'] > dataframe['senkou_a'])
).astype('int') * 2
dataframe['cloud_red_strong'] = (
dataframe['cloud_red'] &
(dataframe['tenkan_sen'] < dataframe['kijun_sen']) &
(dataframe['kijun_sen'] < dataframe['senkou_b'])
).astype('int') * -2
dataframe.loc[
qtpylib.crossed_above(dataframe['tenkan_sen'], dataframe['kijun_sen']),
'tk_cross_up'] = 3
dataframe['tk_cross_up'].fillna(method='ffill', inplace=True, limit=2)
dataframe['tk_cross_up'].fillna(value=0, inplace=True)
# dataframe['rsi_ok'] = (dataframe['rsi'] < 75).astype('int')
dataframe['ema35_ok'] = (
(dataframe['ema3'] > dataframe['ema5']) &
(dataframe['ema5'] > dataframe['ema10'])
).astype('int')
dataframe['spike'] = (
(dataframe['close'] > (dataframe['close'].shift(3) * (1 - self.stoploss * 0.9)))
).astype('int')
dataframe['recent_high'] = dataframe['high'].rolling(12).max()
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe['ema9'] = ta.EMA(dataframe, timeperiod=9)
dataframe['ema21'] = ta.EMA(dataframe, timeperiod=21)
dataframe['ema200'] = ta.EMA(dataframe, timeperiod=200)
return dataframe
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
# Misc. calculations regarding existing open positions (reset on every loop iteration)
self.custom_trade_info[metadata['pair']] = trade_data = {}
trade_data['active_trade'] = trade_data['other_trades'] = False
if self.config['runmode'].value in ('live', 'dry_run'):
active_trade = Trade.get_trades([Trade.pair == metadata['pair'], Trade.is_open.is_(True),]).all()
other_trades = Trade.get_trades([Trade.pair != metadata['pair'], Trade.is_open.is_(True),]).all()
if active_trade:
current_rate = self.get_current_price(metadata['pair'])
active_trade[0].adjust_min_max_rates(current_rate)
trade_data['active_trade'] = True
trade_data['current_profit'] = active_trade[0].calc_profit_ratio(current_rate)
trade_data['peak_profit'] = active_trade[0].calc_profit_ratio(active_trade[0].max_rate)
if other_trades:
trade_data['other_trades'] = True
total_other_profit = tuple(trade.calc_profit_ratio(self.get_current_price(trade.pair)) for trade in other_trades)
trade_data['avg_other_profit'] = mean(total_other_profit)
self.custom_trade_info[metadata['pair']] = trade_data
# Set up other indicators
dataframe['volume_mean_slow'] = dataframe['volume'].rolling(window=24).mean()
dataframe['rmi-slow'] = RMI(dataframe, length=20, mom=5)
dataframe['rmi-fast'] = RMI(dataframe, length=9, mom=3)
dataframe['sar'] = ta.SAR(dataframe)
macd = ta.MACD(dataframe)
dataframe['macd'] = macd['macd']
dataframe['macdsignal'] = macd['macdsignal']
dataframe['macdhist'] = macd['macdhist']
# Trend calculations
dataframe['max'] = dataframe['high'].rolling(12).max()
dataframe['min'] = dataframe['low'].rolling(12).min()
dataframe['upper'] = np.where(dataframe['max'] > dataframe['max'].shift(),1,0)
dataframe['lower'] = np.where(dataframe['min'] < dataframe['min'].shift(),1,0)
dataframe['up_trend'] = np.where(dataframe['upper'].rolling(3, min_periods=1).sum() != 0,1,0)
dataframe['dn_trend'] = np.where(dataframe['lower'].rolling(3, min_periods=1).sum() != 0,1,0)
# Informative Pair Indicators
informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=self.inf_timeframe)
informative['ema3'] = ta.EMA(informative, timeperiod=3)
informative['ema12'] = ta.EMA(informative, timeperiod=12)
inf_macd = ta.MACD(informative)
informative['macd'] = inf_macd['macd']
informative['macdsignal'] = inf_macd['macdsignal']
informative['macdhist'] = inf_macd['macdhist']
dataframe = merge_informative_pair(dataframe, informative, self.timeframe, self.inf_timeframe, ffill=True)
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
# EMAs
dataframe['ema20'] = ta.EMA(dataframe, timeperiod=20)
dataframe['ema60'] = ta.EMA(dataframe, timeperiod=60)
dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
return dataframe
def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
for short in range(shortRangeBegin, shortRangeEnd):
dataframe[f'maShort({short})'] = ta.EMA(dataframe, timeperiod=short)
for medium in range(mediumRangeBegin, mediumRangeEnd):
dataframe[f'maMedium({medium})'] = ta.EMA(dataframe, timeperiod=medium)
return dataframe
def analyze_crossover(self,
historical_data,
hot_thresh=None,
cold_thresh=None,
period_count=(15, 21),
all_data=False):
"""Performs an EMA crossover analysis on the historical data
Args:
historical_data (list): A matrix of historical OHCLV data.
hot_thresh (float, optional): Defaults to None. The threshold at which this might be
good to purchase.
cold_thresh (float, optional): Defaults to None. The threshold at which this might be
good to sell.
period_count (tuple of (2) ints, optional): Defaults to (15, 21). Each number in the tuple
contains the period count of an ema to be used in the crossover analysis
all_data (bool, optional): Defaults to False. If True, we return the EMA associated
with each data point in our historical dataset. Otherwise just return the last one.
Returns:
dict: A dictionary containing a tuple of indicator values and booleans for buy / sell
indication.
"""
dataframe = self.convert_to_dataframe(historical_data)
ema_one_values = abstract.EMA(dataframe, period_count[0])
ema_two_values = abstract.EMA(dataframe, period_count[1])
combined_data = pandas.concat(
[dataframe, ema_one_values, ema_two_values], axis=1)
combined_data.rename(columns={
0: 'ema_value_one',
1: 'ema_value_two'
},
inplace=True)
rows = list(combined_data.iterrows())
# List of 4-tuples containing: (old_ema_one, old_ema_two, current_ema_one, current_ema_two)
analyzed_data = [(math.nan, math.nan, rows[1][1]['ema_value_one'],
rows[1][1]['ema_value_two'])]
# We keep track of the old values as to assign a "hot" value when the first ema crosses over
# the second one, and assign a "cold" value when the second ema crosses over the first
for i in range(1, len(rows)):
analyzed_data.append(
(analyzed_data[i - 1][2], analyzed_data[i - 1][3],
rows[i][1]['ema_value_one'], rows[i][1]['ema_value_two']))
return self.analyze_results(
analyzed_data,
is_hot=lambda o1, o2, c1, c2: o1 < o2 and c1 > c2
if hot_thresh else False,
is_cold=lambda o1, o2, c1, c2: o1 > o2 and c1 < c2
if cold_thresh else False,
all_data=all_data)
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
# Populate/update the trade data if there is any, set trades to false if not live/dry
self.custom_trade_info[metadata['pair']] = self.populate_trades(
metadata['pair'])
dataframe['rsi'] = np.nan_to_num(ta.RSI(dataframe, timeperiod=5))
dataframe['emarsi'] = np.nan_to_num(
ta.EMA(dataframe['rsi'], timeperiod=5))
dataframe['adx'] = np.nan_to_num(ta.ADX(dataframe))
dataframe['minusdi'] = np.nan_to_num(ta.MINUS_DI(dataframe))
dataframe['minusdiema'] = np.nan_to_num(
ta.EMA(dataframe['minusdi'], timeperiod=25))
dataframe['plusdi'] = np.nan_to_num(ta.PLUS_DI(dataframe))
dataframe['plusdiema'] = np.nan_to_num(
ta.EMA(dataframe['plusdi'], timeperiod=5))
dataframe['lowsma'] = np.nan_to_num(ta.EMA(dataframe, timeperiod=60))
dataframe['highsma'] = np.nan_to_num(ta.EMA(dataframe, timeperiod=120))
dataframe['fastsma'] = np.nan_to_num(ta.SMA(dataframe, timeperiod=120))
dataframe['slowsma'] = np.nan_to_num(ta.SMA(dataframe, timeperiod=240))
dataframe['bigup'] = dataframe['fastsma'].gt(dataframe['slowsma']) & (
(dataframe['fastsma'] - dataframe['slowsma']) >
dataframe['close'] / 300)
dataframe['bigdown'] = ~dataframe['bigup']
dataframe['trend'] = dataframe['fastsma'] - dataframe['slowsma']
dataframe['preparechangetrend'] = dataframe['trend'].gt(
dataframe['trend'].shift())
dataframe['preparechangetrendconfirm'] = dataframe[
'preparechangetrend'] & dataframe['trend'].shift().gt(
dataframe['trend'].shift(2))
dataframe['continueup'] = dataframe['slowsma'].gt(
dataframe['slowsma'].shift()) & dataframe['slowsma'].shift().gt(
dataframe['slowsma'].shift(2))
dataframe['delta'] = dataframe['fastsma'] - dataframe['fastsma'].shift(
)
dataframe['slowingdown'] = dataframe['delta'].lt(
dataframe['delta'].shift())
dataframe['rmi-slow'] = RMI(dataframe, length=21, mom=5)
dataframe['rmi-fast'] = RMI(dataframe, length=8, mom=4)
dataframe['rmi-up'] = np.where(
dataframe['rmi-slow'] >= dataframe['rmi-slow'].shift(), 1, 0)
dataframe['rmi-dn'] = np.where(
dataframe['rmi-slow'] <= dataframe['rmi-slow'].shift(), 1, 0)
dataframe['rmi-up-trend'] = np.where(
dataframe['rmi-up'].rolling(3, min_periods=1).sum() >= 2, 1, 0)
dataframe['rmi-dn-trend'] = np.where(
dataframe['rmi-dn'].rolling(3, min_periods=1).sum() >= 2, 1, 0)
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
# Set Up Bollinger Bands
upper_bb1, mid_bb1, lower_bb1 = ta.BBANDS(dataframe['close'],
timeperiod=36)
upper_bb2, mid_bb2, lower_bb2 = ta.BBANDS(
qtpylib.typical_price(dataframe), timeperiod=12)
# Only putting some bands into dataframe as the others are not used elsewhere in the strategy
dataframe['lower-bb1'] = lower_bb1
dataframe['lower-bb2'] = lower_bb2
dataframe['mid-bb2'] = mid_bb2
dataframe['bb1-delta'] = (mid_bb1 - dataframe['lower-bb1']).abs()
dataframe['closedelta'] = (dataframe['close'] -
dataframe['close'].shift()).abs()
dataframe['tail'] = (dataframe['close'] - dataframe['low']).abs()
# Additional indicators
dataframe['ema_fast'] = ta.EMA(dataframe['close'], timeperiod=6)
dataframe['ema_slow'] = ta.EMA(dataframe['close'], timeperiod=48)
dataframe['volume_mean_slow'] = dataframe['volume'].rolling(
window=24).mean()
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
# Inverse Fisher transform on RSI: values [-1.0, 1.0] (https://goo.gl/2JGGoy)
rsi = 0.1 * (dataframe['rsi'] - 50)
dataframe['fisher-rsi'] = (np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1)
# Informative Pair Indicators
coin, stake = metadata['pair'].split('/')
fiat = self.fiat
stake_fiat = f"{stake}/{self.fiat}"
coin_fiat = f"{coin}/{self.fiat}"
coin_fiat_inf = self.dp.get_pair_dataframe(pair=f"{coin}/{fiat}",
timeframe=self.timeframe)
dataframe['coin-fiat-adx'] = ta.ADX(coin_fiat_inf, timeperiod=21)
coin_aroon = ta.AROON(coin_fiat_inf, timeperiod=25)
dataframe['coin-fiat-aroon-down'] = coin_aroon['aroondown']
dataframe['coin-fiat-aroon-up'] = coin_aroon['aroonup']
stake_fiat_inf = self.dp.get_pair_dataframe(pair=f"{stake}/{fiat}",
timeframe=self.timeframe)
dataframe['stake-fiat-adx'] = ta.ADX(stake_fiat_inf, timeperiod=21)
stake_aroon = ta.AROON(stake_fiat_inf, timeperiod=25)
dataframe['stake-fiat-aroon-down'] = stake_aroon['aroondown']
dataframe['stake-fiat-aroon-up'] = stake_aroon['aroonup']
# These indicators are used to persist a buy signal in live trading only
# They dramatically slow backtesting down
if self.config['runmode'].value in ('live', 'dry_run'):
dataframe['sar'] = ta.SAR(dataframe)
return dataframe
