def init_state(self, X, test):
'''
Initializes state space for reinforcement learning
'''
data = []
close = []
for i, s in enumerate(self.symbols):
# Process data using technical analysis library
close.append(X[s]['close'])
diff = np.diff(close[i])
diff = np.insert(diff, 0, 0)
sma15 = ta.SMA(X[s], timeperiod=14)
sma60 = ta.SMA(X[s], timeperiod=56)
rsi = ta.RSI(X[s], timeperiod=14)
atr = ta.ATR(X[s], timeperiod=14)
data.append(
np.nan_to_num(
np.vstack((close[i], diff, sma15, close[i] - sma15,
sma15 - sma60, rsi, atr))))
data[i] = np.expand_dims(data[i], axis=1)
data = np.hstack(data).T
close = np.vstack(close)
state = data[0:1, :, :]
if test:
self.data_test = data
else:
self.data = data
return state, close
def checking_ATR(self):
price_high = []
price_low = []
price_close = []
for stick in self.newCandleStickArr_15m:
price_high.append(float(stick.high))
price_low.append(float(stick.low))
price_close.append(float(stick.close))
price_high_np = np.array(price_high, dtype='f8')
price_low_np = np.array(price_low, dtype='f8')
price_close_np = np.array(price_close, dtype='f8')
real = ta.ATR(price_high_np, price_low_np, price_close_np, timeperiod=15)
sum_15m_20 = 0
for price in self.newCandleStickArr_15m[-20:]:
sum_15m_20 += float(price.close)
avg_15m_20 = sum_15m_20 / 20
high = avg_15m_20 + (float(real[-1]) * 2)
low = avg_15m_20 - (float(real[-1]) * 2)
sum_15m_7 = 0
for price in self.newCandleStickArr_15m[-7:]:
sum_15m_7 += float(price.close)
avg_15m_7 = sum_15m_7 / 7
self.ATR_band_15_Top = high #20일 이평선 기준으로 2 ATR을 빼고 더한것
self.ATR_band_15_bottom = low
self.moving_average_15m_7 = avg_15m_7 #7일 이평선에 닿으면 청산
self.moving_average_15m_20 = avg_15m_20
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 calculator_talib(data):
ETF = {
'open': data[OHLCV_columns[0]].dropna().astype(float),
'high': data[OHLCV_columns[1]].dropna().astype(float),
'low': data[OHLCV_columns[2]].dropna().astype(float),
'close': data[OHLCV_columns[3]].dropna().astype(float),
'volume': data[OHLCV_columns[4]].dropna().astype(float)
}
def talib2df(talib_output):
if type(talib_output) == list:
ret = pd.DataFrame(talib_output).transpose()
else:
ret = pd.Series(talib_output)
ret.index = data['收盤價'].index
return ret
KD = talib2df(abstract.STOCH(ETF, fastk_period=9))
#計算MACD#
MACD = talib2df(abstract.MACD(ETF))
#計算OBV#
OBV = talib2df(abstract.OBV(ETF))
#計算威廉指數#
WILLR = talib2df(abstract.WILLR(ETF))
#ATR 計算#
ATR = talib2df(abstract.ATR(ETF))
ETF = pd.DataFrame()
ETF = pd.concat([data, KD, MACD, OBV, WILLR, ATR], axis=1)
return ETF
def select(self, codes, data):
for code in codes:
candle = data.history(code,
frequency=self.frequency,
length=self.period + self.length)
atr = abstract.ATR(candle, timeperiod=self.period)
if atr[-1] > atr.mean():
yield code
def apply_indicators(df: pd.DataFrame):
# ADX
df['adx'] = ta.ADX(df)
# EMA
df['ema_5'] = ta.EMA(df, 5)
df['ema_10'] = ta.EMA(df, 10)
df['ema_20'] = ta.EMA(df, 20)
df['ema_50'] = ta.EMA(df, 50)
df['ema_100'] = ta.EMA(df, 100)
df['ema_200'] = ta.EMA(df, 200)
# MACD
macd = ta.MACD(df)
df['macd'] = macd['macd']
df['macdsignal'] = macd['macdsignal']
df['macdhist'] = macd['macdhist']
# inverse Fisher rsi/ RSI
df['rsi'] = ta.RSI(df)
rsi = 0.1 - (df['rsi'] - 50)
df['i_rsi'] = (np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1)
# Stoch fast
stoch_fast = ta.STOCHF(df)
df['fastd'] = stoch_fast['fastd']
df['fastk'] = stoch_fast['fastk']
# Stock slow
stoch_slow = ta.STOCH(df)
df['slowd'] = stoch_slow['slowd']
df['slowk'] = stoch_slow['slowk']
# Bollinger bands
bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(df),
window=20,
stds=2)
df['bb_lowerband'] = bollinger['lower']
df['bb_middleband'] = bollinger['mid']
df['bb_upperband'] = bollinger['upper']
# ROC
df['roc'] = ta.ROC(df, 10)
# CCI
df['cci'] = ta.CCI(df, 14)
# on balance volume
df['obv'] = ta.OBV(df)
# Average True Range
df['atr'] = ta.ATR(df, 14)
df = ichimoku(df)
return df
def SSLChannels(dataframe, length = 7, mode='sma'):
df = dataframe.copy()
df['ATR'] = ta.ATR(df, timeperiod=14)
df['smaHigh'] = df['high'].rolling(length).mean() + df['ATR']
df['smaLow'] = df['low'].rolling(length).mean() - df['ATR']
df['hlv'] = np.where(df['close'] > df['smaHigh'], 1, np.where(df['close'] < df['smaLow'], -1, np.NAN))
df['hlv'] = df['hlv'].ffill()
df['sslDown'] = np.where(df['hlv'] < 0, df['smaHigh'], df['smaLow'])
df['sslUp'] = np.where(df['hlv'] < 0, df['smaLow'], df['smaHigh'])
return df['sslDown'], df['sslUp']
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
# Adding EMA's into the dataframe
dataframe["s1_ema_xs"] = ta.EMA(dataframe, timeperiod=self.s1_ema_xs)
dataframe["s1_ema_sm"] = ta.EMA(dataframe, timeperiod=self.s1_ema_sm)
dataframe["s1_ema_md"] = ta.EMA(dataframe, timeperiod=self.s1_ema_md)
dataframe["s1_ema_xl"] = ta.EMA(dataframe, timeperiod=self.s1_ema_xl)
dataframe["s1_ema_xxl"] = ta.EMA(dataframe, timeperiod=self.s1_ema_xxl)
s2_ema_value = ta.EMA(dataframe, timeperiod=self.s2_ema_input)
s2_ema_xxl_value = ta.EMA(dataframe, timeperiod=200)
dataframe[
"s2_ema"] = s2_ema_value - s2_ema_value * self.s2_ema_offset_input
dataframe[
"s2_ema_xxl_off"] = s2_ema_xxl_value - s2_ema_xxl_value * self.s2_fib_lower_value
dataframe["s2_ema_xxl"] = ta.EMA(dataframe, timeperiod=200)
s2_bb_sma_value = ta.SMA(dataframe, timeperiod=self.s2_bb_sma_length)
s2_bb_std_dev_value = ta.STDDEV(dataframe, self.s2_bb_std_dev_length)
dataframe["s2_bb_std_dev_value"] = s2_bb_std_dev_value
dataframe["s2_bb_lower_band"] = s2_bb_sma_value - (
s2_bb_std_dev_value * self.s2_bb_lower_offset)
s2_fib_atr_value = ta.ATR(dataframe, timeframe=self.s2_fib_atr_len)
s2_fib_sma_value = ta.SMA(dataframe, timeperiod=self.s2_fib_sma_len)
dataframe[
"s2_fib_lower_band"] = s2_fib_sma_value - s2_fib_atr_value * self.s2_fib_lower_value
s3_bollinger = qtpylib.bollinger_bands(
qtpylib.typical_price(dataframe), window=20, stds=3)
dataframe["s3_bb_lowerband"] = s3_bollinger["lower"]
dataframe["s3_ema_long"] = ta.EMA(dataframe,
timeperiod=self.s3_ema_long)
dataframe["s3_ema_short"] = ta.EMA(dataframe,
timeperiod=self.s3_ema_short)
dataframe["s3_fast_ma"] = ta.EMA(
dataframe["volume"] * dataframe["close"],
self.s3_ma_fast) / ta.EMA(dataframe["volume"], self.s3_ma_fast)
dataframe["s3_slow_ma"] = ta.EMA(
dataframe["volume"] * dataframe["close"],
self.s3_ma_slow) / ta.EMA(dataframe["volume"], self.s3_ma_slow)
# Volume weighted MACD
dataframe["fastMA"] = ta.EMA(dataframe["volume"] * dataframe["close"],
12) / ta.EMA(dataframe["volume"], 12)
dataframe["slowMA"] = ta.EMA(dataframe["volume"] * dataframe["close"],
26) / ta.EMA(dataframe["volume"], 26)
dataframe["vwmacd"] = dataframe["fastMA"] - dataframe["slowMA"]
dataframe["signal"] = ta.EMA(dataframe["vwmacd"], 9)
dataframe["hist"] = dataframe["vwmacd"] - dataframe["signal"]
return dataframe
def __init__(self, ticker, start_day=None, length=730):
self.ticker = ticker
if (start_day == None):
today = datetime.today()
start_day = today - timedelta(days=length)
start_str = str(start_day.strftime('%Y-%m-%d'))
end_str = str(today.strftime('%Y-%m-%d'))
else:
start_str = start_day
#start = time.strptime(start_day, "%Y-%m-%d")
start = datetime.strptime(start_str, "%Y-%m-%d")
end_day = start + timedelta(days=length)
end_str = str(end_day.strftime('%Y-%m-%d'))
i = y.get_historical_prices(ticker, start_str, end_str)
#Lag Pandas DataFrame
self.df = pd.DataFrame(i)
#Snu Dataframe
self.df = self.df.transpose()
#endre datatype til float
self.df = self.df.astype(float)
self.df = self.df.rename(
columns={
'Close': 'close',
'High': 'high',
'Open': 'open',
'Low': 'low',
'Volume': 'volume'
})
stoch = abstract.STOCH(self.df, 14, 1, 3)
macd = abstract.MACD(self.df)
atr = abstract.ATR(self.df)
obv = abstract.OBV(self.df)
rsi = abstract.RSI(self.df)
self.df['atr'] = pd.DataFrame(atr)
self.df['obv'] = pd.DataFrame(obv)
self.df['rsi'] = pd.DataFrame(rsi)
#kombinerer to dataframes
self.df = pd.merge(self.df,
pd.DataFrame(macd),
left_index=True,
right_index=True,
how='outer')
self.df = pd.merge(self.df,
stoch,
left_index=True,
right_index=True,
how='outer')
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe['atr'] = ta.ATR(dataframe)
dataframe['stoploss_rate'] = dataframe['close'] - (dataframe['atr'] *
2)
self.custom_info[metadata['pair']] = dataframe[[
'date', 'stoploss_rate'
]].copy().set_index('date')
# all "normal" indicators:
# e.g.
# dataframe['rsi'] = ta.RSI(dataframe)
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe['ohlc4'] = ta.AVGPRICE(dataframe)
dataframe['hlc3'] = (dataframe['high'] + dataframe['low'] +
dataframe['close']) / 3
dataframe['hl2'] = (dataframe['high'] + dataframe['low']) / 2
dataframe['atr'] = ta.ATR(dataframe, timeperiod=10)
dataframe['sar'] = ta.SAR(dataframe)
dataframe = supertrend(dataframe, multiplier=1)
return dataframe
def SuperTrend(dataframe, period=10, multiplier=3, atrtype=1):
import talib.abstract as ta
df = dataframe.copy()
atr = 'ATR_' + str(period)
df[atr] = ta.ATR(df, timeperiod=period)
st = 'ST_' + str(period) + '_' + str(multiplier)
stx = 'STX_' + str(period) + '_' + str(multiplier)
# Compute basic upper and lower bands
if atrtype == 1:
df['basic_ub'] = (df["high"] + df["low"]) / 2 + multiplier * df[atr]
df['basic_lb'] = (df["high"] + df["low"]) / 2 - multiplier * df[atr]
elif atrtype == 2:
df['basic_ub'] = (df["high"] + df["low"] +
df["close"]) / 3 + multiplier * df[atr]
df['basic_lb'] = (df["high"] + df["low"] +
df["close"]) / 3 - multiplier * df[atr]
elif atrtype == 3:
df['basic_ub'] = (df["high"] + df["low"] + df["open"] +
df["close"]) / 4 + multiplier * df[atr]
df['basic_lb'] = (df["high"] + df["low"] + df["open"] +
df["close"]) / 4 - multiplier * df[atr]
# Compute final upper and lower bands
df['final_ub'] = 0.00
df['final_lb'] = 0.00
for i in range(period, len(df)):
df['final_ub'].iat[i] = df['basic_ub'].iat[i] if df['basic_ub'].iat[
i] < df['final_ub'].iat[i - 1] or df['close'].iat[
i - 1] > df['final_ub'].iat[i - 1] else df['final_ub'].iat[i -
1]
df['final_lb'].iat[i] = df['basic_lb'].iat[i] if df['basic_lb'].iat[
i] > df['final_lb'].iat[i - 1] or df['close'].iat[
i - 1] < df['final_lb'].iat[i - 1] else df['final_lb'].iat[i -
1]
# Set the Supertrend value
df[st] = 0.00
for i in range(period, len(df)):
df[st].iat[i] = df['final_ub'].iat[i] if df[st].iat[i - 1] == df['final_ub'].iat[i - 1] and df['close'].iat[i] <= df['final_ub'].iat[i] else \
df['final_lb'].iat[i] if df[st].iat[i - 1] == df['final_ub'].iat[i - 1] and df['close'].iat[i] > df['final_ub'].iat[i] else \
df['final_lb'].iat[i] if df[st].iat[i - 1] == df['final_lb'].iat[i - 1] and df['close'].iat[i] >= df['final_lb'].iat[i] else \
df['final_ub'].iat[i] if df[st].iat[i - 1] == df['final_lb'].iat[i - 1] and df['close'].iat[i] < df['final_lb'].iat[i] else 0.00
# Mark the trend direction up/down
df[stx] = np.where((df[st] > 0.00),
np.where((df['close'] < df[st]), 'down', 'up'), np.NaN)
# Remove basic and final bands from the columns
df.drop(['basic_ub', 'basic_lb', 'final_ub', 'final_lb'],
inplace=True,
axis=1)
df.fillna(0, inplace=True)
return df
def execute(self, pool, context, data):
out = []
for code in pool:
candle = data.history(code,
frequency=self.frequency,
length=self.period + self.length)
try:
atr = abstract.ATR(candle, timeperiod=self.period)
if atr[-1] > atr.mean():
out.append(code)
except Exception as e:
print e
print candle
print 'ATR', out
return out
def SSLChannels_ATR(dataframe, length=7):
"""
SSL Channels with ATR: https://www.tradingview.com/script/SKHqWzql-SSL-ATR-channel/
Credit to @JimmyNixx for python
"""
df = dataframe.copy()
df['ATR'] = ta.ATR(df, timeperiod=14)
df['smaHigh'] = df['high'].rolling(length).mean() + df['ATR']
df['smaLow'] = df['low'].rolling(length).mean() - df['ATR']
df['hlv'] = np.where(df['close'] > df['smaHigh'], 1, np.where(df['close'] < df['smaLow'], -1, np.NAN))
df['hlv'] = df['hlv'].ffill()
df['sslDown'] = np.where(df['hlv'] < 0, df['smaHigh'], df['smaLow'])
df['sslUp'] = np.where(df['hlv'] < 0, df['smaLow'], df['smaHigh'])
return df['sslDown'], df['sslUp']
def do_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
dataframe['ema8'] = ta.EMA(dataframe, timeperiod=8)
dataframe['ema14'] = ta.EMA(dataframe, timeperiod=14)
dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
#RSI
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
#StochRSI
period = 14
smoothD = 3
SmoothK = 3
stochrsi = (dataframe['rsi'] - dataframe['rsi'].rolling(period).min()
) / (dataframe['rsi'].rolling(period).max() -
dataframe['rsi'].rolling(period).min())
dataframe['srsi_k'] = stochrsi.rolling(SmoothK).mean() * 100
dataframe['srsi_d'] = dataframe['srsi_k'].rolling(smoothD).mean()
dataframe.loc[
(dataframe['ema8'] > dataframe['ema14']) &
(dataframe['ema14'] > dataframe['ema50'])
& qtpylib.crossed_above(dataframe['srsi_k'], dataframe['srsi_d']),
'go_long'] = 1
dataframe['go_long'].fillna(0, inplace=True)
dataframe.loc[
qtpylib.crossed_above(dataframe['go_long'], 0),
'take_profit'] = dataframe['close'] + dataframe['atr'] * 2
dataframe['take_profit'].fillna(method='ffill', inplace=True)
dataframe.loc[qtpylib.crossed_above(dataframe['go_long'], 0),
'stop_loss'] = dataframe['close'] - dataframe['atr'] * 3
dataframe['stop_loss'].fillna(method='ffill', inplace=True)
dataframe.loc[qtpylib.crossed_above(dataframe['go_long'], 0),
'stop_pct'] = (dataframe['atr'] * 3) / dataframe['close']
dataframe['stop_pct'].fillna(method='ffill', inplace=True)
# add indicator mapped to correct DatetimeIndex to custom_info
self.custom_info[metadata['pair']] = dataframe[[
'date', 'stop_pct', 'take_profit'
]].copy().set_index('date')
return dataframe
def _process(self, v, param):
data = {
"open" : v["open"].astype(float),
"high" : v["high"].astype(float),
"low" : v["low"].astype(float),
"close" : v["close"].astype(float),
"volume" : v["jdiff_vol"].astype(float)
}
# 이동평균선
if "SMA" in param:
for p in param["SMA"]:
v["SMA" + str(p)] = Series(abstract.SMA(data, p), index=v.index)
# Bollinger Bands
if "BBANDS" in param:
temp = abstract.BBANDS(data, param["BBANDS"][0], param["BBANDS"][1], param["BBANDS"][1])
v["BBANDS-UPPER"] = temp[0]
v["BBANDS-MIDDLE"] = temp[1]
v["BBANDS-LOWER"] = temp[2]
# Slow stochastic
if "STOCH" in param:
temp = abstract.STOCH(data, param["STOCH"][0], param["STOCH"][1], param["STOCH"][2])
v["STOCH-K"] = temp[0]
v["STOCH-D"] = temp[1]
# ATR (Average True Range)
if "ATR" in param:
v["ATR"] = Series(abstract.ATR(data, param["ATR"]), index=v.index)
# MACD (Moving Average Convergence/Divergence)
if "MACD" in param:
temp = abstract.MACD(data, param["MACD"][0], param["MACD"][1], param["MACD"][2])
v["MACD-OUT"] = temp[0]
v["MACD-SIGNAL"] = temp[1]
v["MACD-HIST"] = temp[2]
# RSI (Relative Strength Index)
if "RSI" in param:
v["RSI"] = Series(abstract.RSI(data, param["RSI"]), index=v.index)
def slow_tf_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
displacement = 30
ichimoku = ftt.ichimoku(dataframe,
conversion_line_period=20,
base_line_periods=60,
laggin_span=120,
displacement=displacement
)
dataframe['chikou_span'] = ichimoku['chikou_span']
# 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.loc[:, 'cloud_top'] = dataframe.loc[:, ['senkou_a', 'senkou_b']].max(axis=1)
dataframe.loc[:, 'cloud_bottom'] = dataframe.loc[:, ['senkou_a', 'senkou_b']].min(axis=1)
# DANGER ZONE START
# NOTE: Not actually the future, present data that is normally shifted forward for display as the cloud
dataframe['future_green'] = (dataframe['leading_senkou_span_a'] > dataframe['leading_senkou_span_b']).astype('int') * 2
dataframe['future_red'] = (dataframe['leading_senkou_span_a'] < dataframe['leading_senkou_span_b']).astype('int') * 2
# The chikou_span is shifted into the past, so we need to be careful not to read the
# current value. But if we shift it forward again by displacement it should be safe to use.
# We're effectively "looking back" at where it normally appears on the chart.
dataframe['chikou_high'] = (
(dataframe['chikou_span'] > dataframe['cloud_top'])
).shift(displacement).fillna(0).astype('int')
dataframe['chikou_low'] = (
(dataframe['chikou_span'] < dataframe['cloud_bottom'])
).shift(displacement).fillna(0).astype('int')
# DANGER ZONE END
dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
ssl_down, ssl_up = ssl_atr(dataframe, 10)
dataframe['ssl_down'] = ssl_down
dataframe['ssl_up'] = ssl_up
dataframe['ssl_ok'] = (
(ssl_up > ssl_down)
).astype('int') * 3
dataframe['ssl_bear'] = (
(ssl_up < ssl_down)
).astype('int') * 3
dataframe['ichimoku_ok'] = (
(dataframe['tenkan_sen'] > dataframe['kijun_sen'])
& (dataframe['close'] > dataframe['cloud_top'])
& (dataframe['future_green'] > 0)
& (dataframe['chikou_high'] > 0)
).astype('int') * 4
dataframe['ichimoku_bear'] = (
(dataframe['tenkan_sen'] < dataframe['kijun_sen'])
& (dataframe['close'] < dataframe['cloud_bottom'])
& (dataframe['future_red'] > 0)
& (dataframe['chikou_low'] > 0)
).astype('int') * 4
dataframe['ichimoku_valid'] = (
(dataframe['leading_senkou_span_b'] == dataframe['leading_senkou_span_b']) # not NaN
).astype('int') * 1
dataframe['trend_pulse'] = (
(dataframe['ichimoku_ok'] > 0)
& (dataframe['ssl_ok'] > 0)
).astype('int') * 2
dataframe['bear_trend_pulse'] = (
(dataframe['ichimoku_bear'] > 0)
& (dataframe['ssl_bear'] > 0)
).astype('int') * 2
dataframe['trend_over'] = (
(dataframe['ssl_ok'] == 0)
| (dataframe['close'] < dataframe['cloud_top'])
).astype('int') * 1
dataframe['bear_trend_over'] = (
(dataframe['ssl_bear'] == 0)
| (dataframe['close'] > dataframe['cloud_bottom'])
).astype('int') * 1
dataframe.loc[ (dataframe['trend_pulse'] > 0), 'trending'] = 3
dataframe.loc[ (dataframe['trend_over'] > 0) , 'trending'] = 0
dataframe['trending'].fillna(method='ffill', inplace=True)
dataframe.loc[ (dataframe['bear_trend_pulse'] > 0), 'bear_trending'] = 3
dataframe.loc[ (dataframe['bear_trend_over'] > 0) , 'bear_trending'] = 0
dataframe['bear_trending'].fillna(method='ffill', inplace=True)
return dataframe
def slow_tf_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
displacement = 88
ichimoku = ftt.ichimoku(dataframe,
conversion_line_period=20,
base_line_periods=88,
laggin_span=88,
displacement=displacement)
dataframe['chikou_span'] = ichimoku['chikou_span']
# 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.loc[:, 'cloud_top'] = dataframe.loc[:,
['senkou_a', 'senkou_b'
]].max(axis=1)
dataframe.loc[:,
'cloud_bottom'] = dataframe.loc[:,
['senkou_a', 'senkou_b'
]].min(axis=1)
# DANGER ZONE START
# NOTE: Not actually the future, present data that is normally shifted forward for display as the cloud
dataframe['future_green'] = (
dataframe['leading_senkou_span_a'] >
dataframe['leading_senkou_span_b']).astype('int') * 2
# The chikou_span is shifted into the past, so we need to be careful not to read the
# current value. But if we shift it forward again by displacement it should be safe to use.
# We're effectively "looking back" at where it normally appears on the chart.
dataframe['chikou_high'] = (
(dataframe['chikou_span'] > dataframe['senkou_a']) &
(dataframe['chikou_span'] > dataframe['senkou_b'])
).shift(displacement).fillna(0).astype('int')
# DANGER ZONE END
dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
dataframe['ema200'] = ta.EMA(dataframe, timeperiod=200)
dataframe['ema_ok'] = (
(dataframe['close'] > dataframe['ema50'])
& (dataframe['ema50'] > dataframe['ema200'])).astype('int') * 2
dataframe['efi_base'] = (
(dataframe['close'] - dataframe['close'].shift()) *
dataframe['volume'])
dataframe['efi'] = ta.EMA(dataframe['efi_base'], 13)
dataframe['efi_ok'] = (dataframe['efi'] > 0).astype('int')
dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
ssl_down, ssl_up = ssl_atr(dataframe,
10) #TODO TEST THIS NUMBER WITH HYPEROPT
dataframe['ssl_down'] = ssl_down
dataframe['ssl_up'] = ssl_up
dataframe['ssl_ok'] = ((ssl_up > ssl_down)).astype('int') * 3
dataframe['ichimoku_ok'] = (
(dataframe['tenkan_sen'] > dataframe['kijun_sen'])
& (dataframe['close'] > dataframe['cloud_top'])
& (dataframe['future_green'] > 0)
& (dataframe['chikou_high'] > 0)).astype('int') * 4
dataframe['entry_ok'] = (
(dataframe['efi_ok'] > 0)
& (dataframe['open'] < dataframe['ssl_up'])
& (dataframe['close'] < dataframe['ssl_up'])).astype('int') * 1
dataframe['trend_pulse'] = (
(dataframe['ichimoku_ok'] > 0)
& (dataframe['ssl_ok'] > 0)
& (dataframe['ema_ok'] > 0)).astype('int') * 2
dataframe['trend_over'] = (
(dataframe['ssl_ok'] == 0)).astype('int') * 1
dataframe.loc[(dataframe['trend_pulse'] > 0), 'trending'] = 3
dataframe.loc[(dataframe['trend_over'] > 0), 'trending'] = 0
return dataframe
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'])
# Indicators for ROI and Custom Stoploss
dataframe['atr'] = ta.ATR(dataframe, timeperiod=24)
dataframe['roc'] = ta.ROC(dataframe, timeperiod=9)
dataframe['rmi-slow'] = cta.RMI(dataframe, length=21, mom=5)
# Trends, Peaks and Crosses
dataframe['rmi-up'] = 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)
# strategy BinHV45
mid, lower = cta.bollinger_bands(dataframe['close'], window_size=40, num_of_std=2)
dataframe['lower'] = lower
dataframe['bbdelta'] = (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['ema_slow'] = ta.EMA(dataframe, timeperiod=50)
dataframe['volume_mean_slow'] = dataframe['volume'].rolling(window=30).mean()
# Base pair informative timeframe indicators
informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=self.inf_timeframe)
# Get the "average day range" between the 1d high and 3d low to set up guards
informative['1d_high'] = informative['close'].rolling(24).max()
informative['3d_low'] = informative['close'].rolling(72).min()
informative['adr'] = informative['1d_high'] - informative['3d_low']
dataframe = merge_informative_pair(dataframe, informative, self.timeframe, self.inf_timeframe, ffill=True)
# Other stake specific informative indicators
# e.g if stake is BTC and current coin is XLM (pair: XLM/BTC)
if self.config['stake_currency'] in ('BTC', 'ETH'):
coin, stake = metadata['pair'].split('/')
fiat = self.custom_fiat
coin_fiat = f"{coin}/{fiat}"
stake_fiat = f"{stake}/{fiat}"
# Informative COIN/FIAT e.g. XLM/USD - Base Timeframe
coin_fiat_tf = self.dp.get_pair_dataframe(pair=coin_fiat, timeframe=self.timeframe)
dataframe[f"{fiat}_rmi"] = cta.RMI(coin_fiat_tf, length=21, mom=5)
# Informative STAKE/FIAT e.g. BTC/USD - Base Timeframe
stake_fiat_tf = self.dp.get_pair_dataframe(pair=stake_fiat, timeframe=self.timeframe)
dataframe[f"{stake}_rmi"] = cta.RMI(stake_fiat_tf, length=21, mom=5)
# Informative STAKE/FIAT e.g. BTC/USD - Informative Timeframe
stake_fiat_inf_tf = self.dp.get_pair_dataframe(pair=stake_fiat, timeframe=self.inf_timeframe)
stake_fiat_inf_tf[f"{stake}_rmi"] = cta.RMI(stake_fiat_inf_tf, length=48, mom=5)
dataframe = merge_informative_pair(dataframe, stake_fiat_inf_tf, self.timeframe, self.inf_timeframe, ffill=True)
# Informatives for BTC/STAKE if not in whitelist
else:
pairs = self.dp.current_whitelist()
btc_stake = f"BTC/{self.config['stake_currency']}"
if not btc_stake in pairs:
# BTC/STAKE - Base Timeframe
btc_stake_tf = self.dp.get_pair_dataframe(pair=btc_stake, timeframe=self.timeframe)
dataframe['BTC_rmi'] = cta.RMI(btc_stake_tf, length=14, mom=3)
# BTC/STAKE - Informative Timeframe
btc_stake_inf_tf = self.dp.get_pair_dataframe(pair=btc_stake, timeframe=self.inf_timeframe)
btc_stake_inf_tf['BTC_rmi'] = cta.RMI(btc_stake_inf_tf, length=48, mom=5)
dataframe = merge_informative_pair(dataframe, btc_stake_inf_tf, self.timeframe, self.inf_timeframe, ffill=True)
# Slam some indicators into the trade_info dict so we can dynamic roi and custom stoploss in backtest
if self.dp.runmode.value in ('backtest', 'hyperopt'):
self.custom_trade_info[metadata['pair']]['roc'] = dataframe[['date', 'roc']].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['atr'] = dataframe[['date', 'atr']].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['rmi-slow'] = dataframe[['date', 'rmi-slow']].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['rmi-up-trend'] = dataframe[['date', 'rmi-up-trend']].copy().set_index('date')
return dataframe
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'])
# Base timeframe indicators
dataframe['rmi-slow'] = cta.RMI(dataframe, length=21, mom=5)
dataframe['rmi-fast'] = cta.RMI(dataframe, length=8, mom=4)
# Indicators for ROI and Custom Stoploss
dataframe['atr'] = ta.ATR(dataframe, timeperiod=24)
dataframe['roc'] = ta.ROC(dataframe, timeperiod=9)
# Momentum Pinball: https://www.tradingview.com/script/fBpVB1ez-Momentum-Pinball-Indicator/
dataframe['roc-mp'] = ta.ROC(dataframe, timeperiod=6)
dataframe['mp'] = ta.RSI(dataframe['roc-mp'], timeperiod=6)
# Trends, Peaks and Crosses
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)
# Base pair informative timeframe indicators
informative = self.dp.get_pair_dataframe(pair=metadata['pair'],
timeframe=self.inf_timeframe)
# Get the "average day range" between the 1d high and 3d low to set up guards
informative['1d_high'] = informative['close'].rolling(24).max()
informative['3d_low'] = informative['close'].rolling(72).min()
informative['adr'] = informative['1d_high'] - informative['3d_low']
dataframe = merge_informative_pair(dataframe,
informative,
self.timeframe,
self.inf_timeframe,
ffill=True)
# Other stake specific informative indicators
# e.g if stake is BTC and current coin is XLM (pair: XLM/BTC)
if self.config['stake_currency'] in ('BTC', 'ETH'):
coin, stake = metadata['pair'].split('/')
fiat = self.custom_fiat
coin_fiat = f"{coin}/{fiat}"
stake_fiat = f"{stake}/{fiat}"
# Informative COIN/FIAT e.g. XLM/USD - Base Timeframe
coin_fiat_tf = self.dp.get_pair_dataframe(pair=coin_fiat,
timeframe=self.timeframe)
dataframe[f"{fiat}_rmi"] = cta.RMI(coin_fiat_tf, length=21, mom=5)
# Informative STAKE/FIAT e.g. BTC/USD - Base Timeframe
stake_fiat_tf = self.dp.get_pair_dataframe(
pair=stake_fiat, timeframe=self.timeframe)
dataframe[f"{stake}_rmi"] = cta.RMI(stake_fiat_tf,
length=21,
mom=5)
# Informative STAKE/FIAT e.g. BTC/USD - Informative Timeframe
stake_fiat_inf_tf = self.dp.get_pair_dataframe(
pair=stake_fiat, timeframe=self.inf_timeframe)
stake_fiat_inf_tf[f"{stake}_rmi"] = cta.RMI(stake_fiat_inf_tf,
length=48,
mom=5)
dataframe = merge_informative_pair(dataframe,
stake_fiat_inf_tf,
self.timeframe,
self.inf_timeframe,
ffill=True)
# Informatives for BTC/STAKE if not in whitelist
else:
pairs = self.dp.current_whitelist()
btc_stake = f"BTC/{self.config['stake_currency']}"
if not btc_stake in pairs:
# BTC/STAKE - Base Timeframe
btc_stake_tf = self.dp.get_pair_dataframe(
pair=btc_stake, timeframe=self.timeframe)
dataframe['BTC_rmi'] = cta.RMI(btc_stake_tf, length=14, mom=3)
# BTC/STAKE - Informative Timeframe
btc_stake_inf_tf = self.dp.get_pair_dataframe(
pair=btc_stake, timeframe=self.inf_timeframe)
btc_stake_inf_tf['BTC_rmi'] = cta.RMI(btc_stake_inf_tf,
length=48,
mom=5)
dataframe = merge_informative_pair(dataframe,
btc_stake_inf_tf,
self.timeframe,
self.inf_timeframe,
ffill=True)
# Slam some indicators into the trade_info dict so we can dynamic roi and custom stoploss in backtest
if self.dp.runmode.value in ('backtest', 'hyperopt'):
self.custom_trade_info[metadata['pair']]['roc'] = dataframe[[
'date', 'roc'
]].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['atr'] = dataframe[[
'date', 'atr'
]].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['rmi-slow'] = dataframe[[
'date', 'rmi-slow'
]].copy().set_index('date')
self.custom_trade_info[
metadata['pair']]['rmi-up-trend'] = dataframe[[
'date', 'rmi-up-trend'
]].copy().set_index('date')
return dataframe
def do_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
# Stoch fast - mainly due to 5m timeframes
stoch_fast = ta.STOCHF(dataframe)
dataframe['fastd'] = stoch_fast['fastd']
dataframe['fastk'] = stoch_fast['fastk']
#StochRSI for double checking things
period = 14
smoothD = 3
SmoothK = 3
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
stochrsi = (dataframe['rsi'] - dataframe['rsi'].rolling(period).min()
) / (dataframe['rsi'].rolling(period).max() -
dataframe['rsi'].rolling(period).min())
dataframe['srsi_k'] = stochrsi.rolling(SmoothK).mean() * 100
dataframe['srsi_d'] = dataframe['srsi_k'].rolling(smoothD).mean()
# Bollinger Bands because obviously
bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe),
window=20,
stds=1)
dataframe['bb_lowerband'] = bollinger['lower']
dataframe['bb_middleband'] = bollinger['mid']
dataframe['bb_upperband'] = bollinger['upper']
# SAR Parabol - probably don't need this
dataframe['sar'] = ta.SAR(dataframe)
## confirm wideboi variance signal with bbw expansion
dataframe["bb_width"] = (
(dataframe["bb_upperband"] - dataframe["bb_lowerband"]) /
dataframe["bb_middleband"])
dataframe['bbw_expansion'] = dataframe['bb_width'].rolling(
window=4).apply(self.bbw_expansion)
# confirm entry and exit on smoothed HA
dataframe = self.HA(dataframe, 4)
# thanks to Hansen_Khornelius for this idea that I apply to the 1hr informative
# https://github.com/hansen1015/freqtrade_strategy
hansencalc = self.hansen_HA(dataframe, 6)
dataframe['emac'] = hansencalc['emac']
dataframe['emao'] = hansencalc['emao']
# money flow index (MFI) for in/outflow of money, like RSI adjusted for vol
dataframe['mfi'] = fta.MFI(dataframe)
## sqzmi to detect quiet periods
dataframe['sqzmi'] = fta.SQZMI(dataframe) #, MA=hansencalc['emac'])
# Volume Flow Indicator (MFI) for volume based on the direction of price movement
dataframe['vfi'] = fta.VFI(dataframe, period=14)
dmi = fta.DMI(dataframe, period=14)
dataframe['dmi_plus'] = dmi['DI+']
dataframe['dmi_minus'] = dmi['DI-']
dataframe['adx'] = fta.ADX(dataframe, period=14)
## for stoploss - all from Solipsis4
## simple ATR and ROC for stoploss
dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
dataframe['roc'] = ta.ROC(dataframe, timeperiod=9)
dataframe['rmi'] = RMI(dataframe, length=24, mom=5)
ssldown, sslup = SSLChannels_ATR(dataframe, length=21)
dataframe['sroc'] = SROC(dataframe, roclen=21, emalen=13, smooth=21)
dataframe['ssl-dir'] = np.where(sslup > ssldown, 'up', 'down')
dataframe['rmi-up'] = np.where(
dataframe['rmi'] >= dataframe['rmi'].shift(), 1, 0)
dataframe['rmi-up-trend'] = np.where(
dataframe['rmi-up'].rolling(5).sum() >= 3, 1, 0)
dataframe['candle-up'] = np.where(
dataframe['close'] >= dataframe['close'].shift(), 1, 0)
dataframe['candle-up-trend'] = np.where(
dataframe['candle-up'].rolling(5).sum() >= 3, 1, 0)
return dataframe
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
if not metadata['pair'] in self.custom_trade_info:
self.custom_trade_info[metadata['pair']] = {}
c = Consensus(dataframe)
# Overlap / MA's
c.evaluate_tema(period=12)
c.evaluate_ema(period=6)
c.evaluate_ema(period=12)
c.evaluate_sma(period=12)
c.evaluate_ichimoku() # slightly slow
#c.evaluate_hull() # very slow
c.evaluate_vwma(period=20)
# Oscillators
c.evaluate_rsi(period=14)
c.evaluate_stoch()
#c.evaluate_cci() # slightly slow
#c.evaluate_adx()
c.evaluate_macd()
c.evaluate_momentum()
c.evaluate_williams()
# c.evaluate_ultimate_oscilator() # extremely slow
# missing: awesome osc
# missing: bull bear
# missing: stoch rsi
#c.evaluate_macd_cross_over()
c.evaluate_osc()
c.evaluate_cmf()
c.evaluate_cmo() # slightly slow
#c.evaluate_laguerre() # slow
dataframe['consensus-buy'] = c.score()['buy']
dataframe['consensus-sell'] = c.score()['sell']
# Indicators for ROI and Custom Stoploss
dataframe['atr'] = ta.ATR(dataframe, timeperiod=24)
dataframe['roc'] = ta.ROC(dataframe, timeperiod=9)
# Trend Indicators for ROI
dataframe['rmi-slow'] = cta.RMI(dataframe, length=21, mom=5)
dataframe['rmi-up'] = 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)
# Base pair informative timeframe indicators
informative = self.dp.get_pair_dataframe(pair=metadata['pair'],
timeframe=self.inf_timeframe)
# Get the "average day range" between the 1d high and 3d low to set up guards
informative['1d_high'] = informative['close'].rolling(24).max()
informative['3d_low'] = informative['close'].rolling(72).min()
informative['adr'] = informative['1d_high'] - informative['3d_low']
dataframe = merge_informative_pair(dataframe,
informative,
self.timeframe,
self.inf_timeframe,
ffill=True)
# Other stake specific informative indicators
# e.g if stake is BTC and current coin is XLM (pair: XLM/BTC)
if self.config['stake_currency'] in ('BTC', 'ETH'):
coin, stake = metadata['pair'].split('/')
fiat = self.custom_fiat
coin_fiat = f"{coin}/{fiat}"
stake_fiat = f"{stake}/{fiat}"
# Informative COIN/FIAT e.g. XLM/USD - Base Timeframe
coin_fiat_tf = self.dp.get_pair_dataframe(pair=coin_fiat,
timeframe=self.timeframe)
dataframe[f"{fiat}_rmi"] = cta.RMI(coin_fiat_tf, length=21, mom=5)
# Informative STAKE/FIAT e.g. BTC/USD - Base Timeframe
stake_fiat_tf = self.dp.get_pair_dataframe(
pair=stake_fiat, timeframe=self.timeframe)
dataframe[f"{stake}_rmi"] = cta.RMI(stake_fiat_tf,
length=21,
mom=5)
# Informative STAKE/FIAT e.g. BTC/USD - Informative Timeframe
stake_fiat_inf_tf = self.dp.get_pair_dataframe(
pair=stake_fiat, timeframe=self.inf_timeframe)
stake_fiat_inf_tf[f"{stake}_rmi"] = cta.RMI(stake_fiat_inf_tf,
length=48,
mom=5)
dataframe = merge_informative_pair(dataframe,
stake_fiat_inf_tf,
self.timeframe,
self.inf_timeframe,
ffill=True)
# Informatives for BTC/STAKE if not in whitelist
else:
pairs = self.dp.current_whitelist()
btc_stake = f"BTC/{self.config['stake_currency']}"
if not btc_stake in pairs:
# BTC/STAKE - Base Timeframe
btc_stake_tf = self.dp.get_pair_dataframe(
pair=btc_stake, timeframe=self.timeframe)
cbtc = Consensus(btc_stake_tf)
cbtc.evaluate_tema(period=12)
cbtc.evaluate_ema(period=12)
cbtc.evaluate_ema(period=24)
cbtc.evaluate_sma(period=12)
cbtc.evaluate_ichimoku()
cbtc.evaluate_vwma(period=20)
cbtc.evaluate_rsi(period=14)
cbtc.evaluate_stoch()
cbtc.evaluate_macd()
cbtc.evaluate_momentum()
cbtc.evaluate_williams()
cbtc.evaluate_osc()
cbtc.evaluate_cmf()
cbtc.evaluate_cmo()
cbtc.evaluate_laguerre()
dataframe['BTC_consensus-buy'] = cbtc.score()['buy']
# BTC/STAKE - Informative Timeframe
# btc_stake_inf_tf = self.dp.get_pair_dataframe(pair=btc_stake, timeframe=self.inf_timeframe)
# dataframe = merge_informative_pair(dataframe, btc_stake_inf_tf, self.timeframe, self.inf_timeframe, ffill=True)
# Slam some indicators into the trade_info dict so we can dynamic roi and custom stoploss in backtest
if self.dp.runmode.value in ('backtest', 'hyperopt'):
# Attempting to use a temporary holding place for dynamic roi backtest return value...
if not 'backtest' in self.custom_trade_info:
self.custom_trade_info['backtest'] = {}
self.custom_trade_info[metadata['pair']]['roc'] = dataframe[[
'date', 'roc'
]].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['atr'] = dataframe[[
'date', 'atr'
]].copy().set_index('date')
self.custom_trade_info[metadata['pair']]['rmi-slow'] = dataframe[[
'date', 'rmi-slow'
]].copy().set_index('date')
self.custom_trade_info[
metadata['pair']]['rmi-up-trend'] = dataframe[[
'date', 'rmi-up-trend'
]].copy().set_index('date')
self.custom_trade_info[
metadata['pair']]['consensus-buy'] = dataframe[[
'date', 'consensus-buy'
]].copy().set_index('date')
self.custom_trade_info[
metadata['pair']]['consensus-sell'] = dataframe[[
'date', 'consensus-sell'
]].copy().set_index('date')
return dataframe
def PMAX(dataframe, period=4, multiplier=0.1, length=4, MAtype=7, src=1):
import talib.abstract as ta
df = dataframe.copy()
mavalue = 'MA_' + str(MAtype) + '_' + str(length)
atr = 'ATR_' + str(period)
df[atr] = ta.ATR(df, timeperiod=period)
pm = 'pm_' + str(period) + '_' + str(multiplier) + '_' + str(length) + '_' + str(MAtype)
pmx = 'pmX_' + str(period) + '_' + str(multiplier) + '_' + str(length) + '_' + str(MAtype)
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:
df[mavalue] = ta.EMA(masrc, timeperiod=length)
elif MAtype == 2:
df[mavalue] = ta.DEMA(masrc, timeperiod=length)
elif MAtype == 3:
df[mavalue] = ta.T3(masrc, timeperiod=length)
elif MAtype == 4:
df[mavalue] = ta.SMA(masrc, timeperiod=length)
elif MAtype == 5:
df[mavalue] = VIDYA(df, length=length)
elif MAtype == 6:
df[mavalue] = ta.TEMA(masrc, timeperiod=length)
elif MAtype == 7:
df[mavalue] = ta.WMA(df, timeperiod=length)
elif MAtype == 8:
df[mavalue] = vwma(df, length)
elif MAtype == 9:
df[mavalue] = zema(df, period=length)
# Compute basic upper and lower bands
df['basic_ub'] = df[mavalue] + (multiplier * df[atr])
df['basic_lb'] = df[mavalue] - (multiplier * df[atr])
# Compute final upper and lower bands
df['final_ub'] = 0.00
df['final_lb'] = 0.00
for i in range(period, len(df)):
df['final_ub'].iat[i] = df['basic_ub'].iat[i] if (
df['basic_ub'].iat[i] < df['final_ub'].iat[i - 1]
or df[mavalue].iat[i - 1] > df['final_ub'].iat[i - 1]) else df['final_ub'].iat[i - 1]
df['final_lb'].iat[i] = df['basic_lb'].iat[i] if (
df['basic_lb'].iat[i] > df['final_lb'].iat[i - 1]
or df[mavalue].iat[i - 1] < df['final_lb'].iat[i - 1]) else df['final_lb'].iat[i - 1]
df[pm] = 0.00
for i in range(period, len(df)):
df[pm].iat[i] = (
df['final_ub'].iat[i] if (df[pm].iat[i - 1] == df['final_ub'].iat[i - 1]
and df[mavalue].iat[i] <= df['final_ub'].iat[i])
else df['final_lb'].iat[i] if (
df[pm].iat[i - 1] == df['final_ub'].iat[i - 1]
and df[mavalue].iat[i] > df['final_ub'].iat[i]) else df['final_lb'].iat[i]
if (df[pm].iat[i - 1] == df['final_lb'].iat[i - 1]
and df[mavalue].iat[i] >= df['final_lb'].iat[i]) else df['final_ub'].iat[i]
if (df[pm].iat[i - 1] == df['final_lb'].iat[i - 1]
and df[mavalue].iat[i] < df['final_lb'].iat[i]) else 0.00)
# up/down belirteçi / main logic
df[pmx] = np.where((df[pm] > 0.00), np.where((df[mavalue] < df[pm]), 'down', 'up'), np.NaN)
df.drop(['basic_ub', 'basic_lb', 'final_ub', 'final_lb'], inplace=True, axis=1)
df.fillna(0, inplace=True)
return df
def populate_indicators(self, dataframe: DataFrame,
metadata: dict) -> DataFrame:
dataframe['ATR'] = ta.ATR(dataframe, timeperiod=5)
brick_size = np.mean(dataframe['ATR'])
columns = ['date', 'open', 'high', 'low', 'close', 'volume', 'ATR']
df = dataframe[columns]
cdf = pd.DataFrame(
columns=columns,
data=[],
)
cdf.loc[0] = df.loc[0]
close = df.loc[0]['close']
volume = df.loc[0]['volume']
cdf.iloc[0, 1:] = [
close - brick_size, close, close - brick_size, close, volume,
brick_size
]
cdf['trend'] = True
columns = [
'date', 'open', 'high', 'low', 'close', 'volume', 'ATR', 'trend'
]
for index, row in df.iterrows():
if not np.isnan(row['ATR']): brick_size = row['ATR']
close = row['close']
date = row['date']
volume = row['volume']
row_p1 = cdf.iloc[-1]
trend = row_p1['trend']
close_p1 = row_p1['close']
bricks = int(np.nan_to_num((close - close_p1) / brick_size))
data = []
if trend and bricks >= 1:
for i in range(bricks):
r = [
date, close_p1, close_p1 + brick_size, close_p1,
close_p1 + brick_size, volume, brick_size, trend
]
data.append(r)
close_p1 += brick_size
elif trend and bricks <= -2:
trend = not trend
bricks += 1
close_p1 -= brick_size
for i in range(abs(bricks)):
r = [
date, close_p1, close_p1, close_p1 - brick_size,
close_p1 - brick_size, volume, brick_size, trend
]
data.append(r)
close_p1 -= brick_size
elif not trend and bricks <= -1:
for i in range(abs(bricks)):
r = [
date, close_p1, close_p1, close_p1 - brick_size,
close_p1 - brick_size, volume, brick_size, trend
]
data.append(r)
close_p1 -= brick_size
elif not trend and bricks >= 2:
trend = not trend
bricks -= 1
close_p1 += brick_size
for i in range(abs(bricks)):
r = [
date, close_p1, close_p1 + brick_size, close_p1,
close_p1 + brick_size, volume, brick_size, trend
]
data.append(r)
close_p1 += brick_size
else:
continue
sdf = pd.DataFrame(data=data, columns=columns)
cdf = pd.concat([cdf, sdf])
renko_df = cdf.groupby(['date']).last()
renko_df = renko_df.reset_index()
renko_df['previous-trend'] = renko_df.trend.shift(1)
renko_df['previous-trend2'] = renko_df.trend.shift(2)
return renko_df
